[Design Patterns] 17. 패턴의 조합과 상호작용: 설계의 협주곡

 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

// Factory + Singleton 조합의 우아함
public class DatabaseConnectionFactory {
    private static volatile DatabaseConnectionFactory instance;
    private final Map<String, DataSource> dataSources;
    private final ConnectionPoolManager poolManager;
    
    private DatabaseConnectionFactory() {
        this.dataSources = new ConcurrentHashMap<>();
        this.poolManager = new ConnectionPoolManager();
        initializeDataSources();
    }
    
    // Singleton 보장
    public static DatabaseConnectionFactory getInstance() {
        if (instance == null) {
            synchronized (DatabaseConnectionFactory.class) {
                if (instance == null) {
                    instance = new DatabaseConnectionFactory();
                }
            }
        }
        return instance;
    }
    
    // Factory Method 패턴
    public Connection createConnection(DatabaseType type) {
        DataSource dataSource = dataSources.get(type.getName());
        if (dataSource == null) {
            throw new IllegalArgumentException("Unsupported database type: " + type);
        }
        
        try {
            Connection connection = dataSource.getConnection();
            return new MonitoredConnection(connection, poolManager);
        } catch (SQLException e) {
            throw new RuntimeException("Failed to create connection", e);
        }
    }
    
    // Abstract Factory 패턴 (타입별 특화 팩토리)
    public DatabaseOperations createOperations(DatabaseType type) {
        switch (type) {
            case MYSQL:
                return new MySQLOperations(createConnection(type));
            case POSTGRESQL:
                return new PostgreSQLOperations(createConnection(type));
            case ORACLE:
                return new OracleOperations(createConnection(type));
            default:
                throw new IllegalArgumentException("Unsupported database type: " + type);
        }
    }
    
    private void initializeDataSources() {
        // 데이터소스 초기화 로직
        dataSources.put("mysql", createMySQLDataSource());
        dataSources.put("postgresql", createPostgreSQLDataSource());
        dataSources.put("oracle", createOracleDataSource());
    }
}

// 사용 예시
public class DatabaseService {
    private final DatabaseConnectionFactory factory;
    
    public DatabaseService() {
        // Singleton 팩토리 사용
        this.factory = DatabaseConnectionFactory.getInstance();
    }
    
    public void performDatabaseOperation(DatabaseType type) {
        // Factory로 적절한 연결과 연산 객체 생성
        DatabaseOperations ops = factory.createOperations(type);
        ops.executeQuery("SELECT * FROM users");
    }
}

  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

// Observer + Command 조합
public class EventDrivenOrderSystem {
    private final List<OrderEventObserver> observers;
    private final CommandQueue commandQueue;
    private final CommandProcessor processor;
    
    public EventDrivenOrderSystem() {
        this.observers = new CopyOnWriteArrayList<>();
        this.commandQueue = new LinkedBlockingQueue<>();
        this.processor = new CommandProcessor(commandQueue);
        setupObservers();
    }
    
    private void setupObservers() {
        // 각 Observer가 특정 Command를 생성하도록 설계
        addObserver(new InventoryObserver());
        addObserver(new PaymentObserver());
        addObserver(new NotificationObserver());
        addObserver(new AuditObserver());
    }
    
    public void addObserver(OrderEventObserver observer) {
        observers.add(observer);
    }
    
    public void processOrder(Order order) {
        // 주문 처리 이벤트 발생
        OrderEvent event = new OrderEvent(OrderEventType.ORDER_PLACED, order);
        notifyObservers(event);
    }
    
    private void notifyObservers(OrderEvent event) {
        for (OrderEventObserver observer : observers) {
            try {
                // Observer가 Command 생성
                List<Command> commands = observer.handleEvent(event);
                
                // 생성된 Command들을 큐에 추가
                for (Command command : commands) {
                    commandQueue.offer(command);
                }
            } catch (Exception e) {
                System.err.println("Observer failed: " + e.getMessage());
            }
        }
    }
}

// Observer 구현체
class InventoryObserver implements OrderEventObserver {
    private final InventoryService inventoryService;
    
    public InventoryObserver() {
        this.inventoryService = new InventoryService();
    }
    
    @Override
    public List<Command> handleEvent(OrderEvent event) {
        List<Command> commands = new ArrayList<>();
        
        if (event.getType() == OrderEventType.ORDER_PLACED) {
            Order order = event.getOrder();
            
            // 재고 차감 Command 생성
            for (OrderItem item : order.getItems()) {
                commands.add(new DeductInventoryCommand(
                    inventoryService, 
                    item.getProductId(), 
                    item.getQuantity()
                ));
            }
            
            // 재고 부족 시 알림 Command 생성
            commands.add(new CheckLowStockCommand(inventoryService, order));
        }
        
        return commands;
    }
}

// Command 구현체
class DeductInventoryCommand implements Command {
    private final InventoryService inventoryService;
    private final String productId;
    private final int quantity;
    private int deductedQuantity = 0;
    
    public DeductInventoryCommand(InventoryService service, String productId, int quantity) {
        this.inventoryService = service;
        this.productId = productId;
        this.quantity = quantity;
    }
    
    @Override
    public void execute() {
        deductedQuantity = inventoryService.deductStock(productId, quantity);
        System.out.println("Deducted " + deductedQuantity + " units of " + productId);
    }
    
    @Override
    public void undo() {
        if (deductedQuantity > 0) {
            inventoryService.addStock(productId, deductedQuantity);
            System.out.println("Restored " + deductedQuantity + " units of " + productId);
        }
    }
}

  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

// Decorator + Strategy 조합
// 기본 서비스 인터페이스
interface PaymentService {
    PaymentResult processPayment(PaymentRequest request);
}

// 기본 구현
class BasicPaymentService implements PaymentService {
    private PaymentStrategy strategy;
    
    public BasicPaymentService(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        return strategy.process(request);
    }
    
    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
}

// Decorator 기본 클래스
abstract class PaymentServiceDecorator implements PaymentService {
    protected final PaymentService decoratedService;
    
    public PaymentServiceDecorator(PaymentService service) {
        this.decoratedService = service;
    }
    
    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        return decoratedService.processPayment(request);
    }
}

// 로깅 Decorator
class LoggingPaymentDecorator extends PaymentServiceDecorator {
    private final Logger logger;
    
    public LoggingPaymentDecorator(PaymentService service) {
        super(service);
        this.logger = LoggerFactory.getLogger(LoggingPaymentDecorator.class);
    }
    
    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        logger.info("Processing payment: {} for amount: {}", 
                   request.getPaymentMethod(), request.getAmount());
        
        long startTime = System.currentTimeMillis();
        PaymentResult result = super.processPayment(request);
        long endTime = System.currentTimeMillis();
        
        logger.info("Payment processed in {}ms. Result: {}", 
                   endTime - startTime, result.isSuccess() ? "SUCCESS" : "FAILED");
        
        return result;
    }
}

// 캐싱 Decorator
class CachingPaymentDecorator extends PaymentServiceDecorator {
    private final Map<String, PaymentResult> cache;
    private final Duration cacheTimeout;
    
    public CachingPaymentDecorator(PaymentService service, Duration cacheTimeout) {
        super(service);
        this.cache = new ConcurrentHashMap<>();
        this.cacheTimeout = cacheTimeout;
    }
    
    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        String cacheKey = generateCacheKey(request);
        
        // 캐시 확인 (중복 결제 방지)
        PaymentResult cachedResult = cache.get(cacheKey);
        if (cachedResult != null && !isCacheExpired(cachedResult)) {
            return PaymentResult.duplicate(cachedResult);
        }
        
        PaymentResult result = super.processPayment(request);
        
        // 성공한 결제만 캐시
        if (result.isSuccess()) {
            cache.put(cacheKey, result);
        }
        
        return result;
    }
    
    private String generateCacheKey(PaymentRequest request) {
        return request.getCustomerId() + "_" + 
               request.getAmount() + "_" + 
               request.getCurrency() + "_" + 
               request.getTimestamp().truncatedTo(ChronoUnit.MINUTES);
    }
}

// 재시도 Decorator
class RetryPaymentDecorator extends PaymentServiceDecorator {
    private final int maxRetries;
    private final Duration retryDelay;
    
    public RetryPaymentDecorator(PaymentService service, int maxRetries, Duration retryDelay) {
        super(service);
        this.maxRetries = maxRetries;
        this.retryDelay = retryDelay;
    }
    
    @Override
    public PaymentResult processPayment(PaymentRequest request) {
        for (int attempt = 1; attempt <= maxRetries; attempt++) {
            try {
                PaymentResult result = super.processPayment(request);
                
                if (result.isSuccess() || !result.isRetryable()) {
                    return result;
                }
                
                if (attempt < maxRetries) {
                    System.out.println("Payment attempt " + attempt + " failed. Retrying in " + 
                                     retryDelay.toMillis() + "ms");
                    Thread.sleep(retryDelay.toMillis());
                }
                
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return PaymentResult.failed("Payment interrupted");
            } catch (Exception e) {
                if (attempt == maxRetries) {
                    return PaymentResult.failed("Payment failed after " + maxRetries + " attempts");
                }
            }
        }
        
        return PaymentResult.failed("Payment failed after " + maxRetries + " attempts");
    }
}

// 사용 예시 - 패턴들의 아름다운 조합
public class PaymentSystemDemo {
    public static void main(String[] args) {
        // Strategy 패턴으로 결제 방식 선택
        PaymentStrategy creditCardStrategy = new CreditCardStrategy();
        PaymentService basicService = new BasicPaymentService(creditCardStrategy);
        
        // Decorator 패턴으로 기능 확장 (체인 형태로)
        PaymentService enhancedService = new LoggingPaymentDecorator(
            new CachingPaymentDecorator(
                new RetryPaymentDecorator(basicService, 3, Duration.ofSeconds(1)),
                Duration.ofMinutes(5)
            )
        );
        
        // 사용
        PaymentRequest request = new PaymentRequest("customer123", 100.0, "USD");
        PaymentResult result = enhancedService.processPayment(request);
        
        System.out.println("Payment result: " + result);
    }
}

 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

// 1. Factory + Singleton + Builder 조합 (ECommerceSystem의 중첩 클래스)
public static class ServiceFactory {
    private static volatile ServiceFactory instance;
    private final Map<Class<?>, Object> services;

    private ServiceFactory() {
        this.services = new ConcurrentHashMap<>();
        initializeServices();
    }

    // DatabaseConnectionFactory(앞 절)와 동일한 이중 검사 락(double-checked locking) 패턴
    public static ServiceFactory getInstance() {
        if (instance == null) {
            synchronized (ServiceFactory.class) {
                if (instance == null) {
                    instance = new ServiceFactory();
                }
            }
        }
        return instance;
    }

    @SuppressWarnings("unchecked")
    public <T> T getService(Class<T> serviceClass) {
        return (T) services.get(serviceClass);
    }

    private void initializeServices() {
        // Builder 패턴: 서비스마다 필요한 협력 객체 조합이 다르므로 생성자 대신 Builder로 조립한다
        UserService userService = new UserServiceBuilder()
            .withRepository(createUserRepository())
            .withValidator(createUserValidator())
            .withNotificationService(createNotificationService())
            .withAuditService(createAuditService())
            .build();

        OrderService orderService = new OrderServiceBuilder()
            .withRepository(createOrderRepository())
            .withInventoryService(createInventoryService())
            .withPaymentService(createPaymentService())
            .withShippingService(createShippingService())
            .build();

        services.put(UserService.class, userService);
        services.put(OrderService.class, orderService);
    }
}

 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

// 최소 컴파일 스텁: ServiceFactory(위 코드)가 참조하는 협력 타입을 완전히 정의한 버전.
// java -source 17 이상에서 별도 의존성 없이 그대로 컴파일·실행된다.
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

class UserRepository { }
class UserValidator { }
class NotificationService { }
class AuditService { }

class UserService {
    private final UserRepository repository;
    private final UserValidator validator;
    private final NotificationService notificationService;
    private final AuditService auditService;

    private UserService(UserRepository repository, UserValidator validator,
                         NotificationService notificationService, AuditService auditService) {
        this.repository = repository;
        this.validator = validator;
        this.notificationService = notificationService;
        this.auditService = auditService;
    }

    static UserService of(UserRepository repository, UserValidator validator,
                          NotificationService notificationService, AuditService auditService) {
        return new UserService(repository, validator, notificationService, auditService);
    }
}

// ServiceFactory.initializeServices()가 사용하는 Builder: 메서드 체이닝으로 협력 객체를 하나씩 채운다
class UserServiceBuilder {
    private UserRepository repository;
    private UserValidator validator;
    private NotificationService notificationService;
    private AuditService auditService;

    UserServiceBuilder withRepository(UserRepository repository) {
        this.repository = repository;
        return this;
    }

    UserServiceBuilder withValidator(UserValidator validator) {
        this.validator = validator;
        return this;
    }

    UserServiceBuilder withNotificationService(NotificationService notificationService) {
        this.notificationService = notificationService;
        return this;
    }

    UserServiceBuilder withAuditService(AuditService auditService) {
        this.auditService = auditService;
        return this;
    }

    UserService build() {
        return UserService.of(repository, validator, notificationService, auditService);
    }
}

// ServiceFactory.getInstance().getService(UserService.class) 호출부가 실제로 성립함을 보이는 최소 데모
public class ServiceFactoryStubDemo {
    public static void main(String[] args) {
        Map<Class<?>, Object> services = new ConcurrentHashMap<>();

        UserService userService = new UserServiceBuilder()
            .withRepository(new UserRepository())
            .withValidator(new UserValidator())
            .withNotificationService(new NotificationService())
            .withAuditService(new AuditService())
            .build();

        services.put(UserService.class, userService);
        System.out.println("Registered: " + services.containsKey(UserService.class));
    }
}

 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

// 2. Observer + Command + Strategy 조합 (ECommerceSystem의 중첩 클래스)
public static class OrderProcessingSystem {
    private final List<OrderObserver> observers;
    private final CommandProcessor commandProcessor;
    private final OrderValidationStrategy validationStrategy;

    public OrderProcessingSystem() {
        this.observers = new ArrayList<>();
        this.commandProcessor = new CommandProcessor();
        this.validationStrategy = new CompositeValidationStrategy();
        setupObservers();
    }

    private void setupObservers() {
        observers.add(new InventoryUpdateObserver());
        observers.add(new PaymentProcessingObserver());
        observers.add(new EmailNotificationObserver());
        observers.add(new AuditLogObserver());
        observers.add(new AnalyticsObserver());
    }

    public OrderResult processOrder(Order order) {
        try {
            // Strategy 패턴으로 주문 검증
            ValidationResult validation = validationStrategy.validate(order);
            if (!validation.isValid()) {
                return OrderResult.validationFailed(validation.getErrors());
            }

            // Observer 패턴으로 이벤트 발생 → 각 Observer가 Command 생성
            OrderEvent event = new OrderEvent(OrderEventType.ORDER_SUBMITTED, order);
            List<Command> commands = notifyObserversAndCollectCommands(event);

            // Command 패턴으로 비즈니스 로직 실행
            ExecutionResult executionResult = commandProcessor.executeAll(commands);

            if (executionResult.isSuccess()) {
                notifyObservers(new OrderEvent(OrderEventType.ORDER_COMPLETED, order));
                return OrderResult.success(order);
            } else {
                // 실패 시 보상 트랜잭션: 이미 실행된 Command들의 undo()를 역순으로 호출
                commandProcessor.undoAll(executionResult.getExecutedCommands());
                notifyObservers(new OrderEvent(OrderEventType.ORDER_FAILED, order));
                return OrderResult.failed(executionResult.getError());
            }

        } catch (Exception e) {
            return OrderResult.error("Order processing failed: " + e.getMessage());
        }
    }

    private List<Command> notifyObserversAndCollectCommands(OrderEvent event) {
        List<Command> allCommands = new ArrayList<>();
        for (OrderObserver observer : observers) {
            try {
                allCommands.addAll(observer.handleEvent(event));
            } catch (Exception e) {
                System.err.println("Observer failed: " + e.getMessage());
            }
        }
        return allCommands;
    }
}

 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

// 3. State + Template Method + Visitor 조합 (ECommerceSystem의 중첩 클래스)
public static abstract class OrderWorkflow {
    protected Order order;
    protected OrderState currentState;

    public OrderWorkflow(Order order) {
        this.order = order;
        this.currentState = new PendingState();
    }

    // Template Method: 워크플로우 실행 골격 (하위 클래스가 재정의할 수 없도록 final)
    public final WorkflowResult executeWorkflow() {
        try {
            onWorkflowStarted();

            while (!currentState.isTerminal()) {
                OrderState previousState = currentState;
                currentState = processCurrentState(); // State: 다음 상태 결정을 위임

                if (currentState != previousState) {
                    onStateTransition(previousState, currentState);
                }
            }

            WorkflowResult result = createFinalResult();
            onWorkflowCompleted(result);
            return result;

        } catch (Exception e) {
            return handleWorkflowError(e);
        }
    }

    // Visitor 패턴: 상태별 부가 연산(리포트, SLA 검사 등)을 OrderState 수정 없이 추가
    public void acceptVisitor(OrderStateVisitor visitor) {
        currentState.accept(visitor);
    }

    // Hook 메서드: 하위 클래스가 필요할 때만 재정의하는 확장 지점 (기본은 빈 구현)
    protected void onWorkflowStarted() { }
    protected void onStateTransition(OrderState from, OrderState to) { }
    protected void onWorkflowCompleted(WorkflowResult result) { }

    // Abstract 메서드: 상태 전이와 결과 생성은 워크플로우 종류(일반/예약/구독)마다 다르다
    protected abstract OrderState processCurrentState();
    protected abstract WorkflowResult createFinalResult();
    protected abstract WorkflowResult handleWorkflowError(Exception e);
}

 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

// 4. Decorator + Composite + Facade 조합 (ECommerceSystem의 중첩 클래스)
public static class OrderValidationService {
    private final ValidationComponent rootValidator;

    public OrderValidationService() {
        this.rootValidator = buildValidationTree();
    }

    private ValidationComponent buildValidationTree() {
        // Composite 패턴으로 검증 트리 구성 (그룹별 CompositeValidator)
        CompositeValidator root = new CompositeValidator("Root Validator");

        CompositeValidator basic = new CompositeValidator("Basic Validation");
        basic.add(new OrderFormatValidator());
        basic.add(new CustomerValidator());
        basic.add(new ProductValidator());

        CompositeValidator business = new CompositeValidator("Business Validation");
        business.add(new InventoryValidator());
        business.add(new PricingValidator());
        business.add(new PromotionValidator());

        CompositeValidator security = new CompositeValidator("Security Validation");
        security.add(new FraudDetectionValidator());
        security.add(new RateLimitValidator());

        root.add(basic);
        root.add(business);
        root.add(security);

        // Decorator 패턴으로 로깅 → 성능 측정 → 캐싱을 트리 바깥에서 순서대로 적용
        return new LoggingValidationDecorator(
            new PerformanceValidationDecorator(
                new CachingValidationDecorator(root)
            )
        );
    }

    // Facade 패턴: 트리 구성과 데코레이터 체인을 감추고 단일 진입점만 노출
    public ValidationResult validateOrder(Order order) {
        return rootValidator.validate(order);
    }

    public ValidationReport getDetailedValidationReport(Order order) {
        DetailedValidationVisitor visitor = new DetailedValidationVisitor();
        rootValidator.accept(visitor);
        return visitor.getReport();
    }
}

 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

// Model Layer - Repository + Factory + Observer
@Component
public class UserModel {
    private final UserRepository repository;
    private final UserFactory factory;
    private final List<ModelObserver> observers;

    public UserModel(UserRepository repository, UserFactory factory) {
        this.repository = repository;
        this.factory = factory;
        this.observers = new CopyOnWriteArrayList<>();
    }

    public User createUser(UserCreateRequest request) {
        User user = factory.createUser(request);       // Factory: 생성 규칙 캡슐화
        User savedUser = repository.save(user);         // Repository: 영속화
        notifyObservers(new ModelEvent(ModelEventType.USER_CREATED, savedUser)); // Observer: 통지
        return savedUser;
    }

    public void addObserver(ModelObserver observer) {
        observers.add(observer);
    }

    private void notifyObservers(ModelEvent event) {
        observers.forEach(observer -> observer.onModelChanged(event));
    }
}

 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

// View Layer - Composite + Decorator + Template Method
public abstract class BaseView {
    protected final List<ViewComponent> components;
    private final List<ViewDecorator> decorators;

    public BaseView() {
        this.components = new ArrayList<>();
        this.decorators = new ArrayList<>();
    }

    // Template Method: 렌더링 골격은 고정, 각 파트의 내용만 하위 클래스가 채운다
    public final String render() {
        StringBuilder html = new StringBuilder();
        html.append(renderHeader());
        html.append(renderContent());
        html.append(renderFooter());

        String result = html.toString();
        for (ViewDecorator decorator : decorators) {
            result = decorator.decorate(result); // Decorator: 렌더링 결과물에 후처리 적용
        }
        return result;
    }

    protected abstract String renderHeader();
    protected abstract String renderContent();
    protected abstract String renderFooter();

    public void addComponent(ViewComponent component) {  // Composite: 화면 구성 요소 트리
        components.add(component);
    }

    public void addDecorator(ViewDecorator decorator) {   // Decorator 체인 등록
        decorators.add(decorator);
    }
}

 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

// Controller Layer - Command + Chain of Responsibility + Strategy
@RestController
public class UserController {
    private final RequestHandlerChain handlerChain;
    private final CommandProcessor commandProcessor;
    private final ResponseStrategy responseStrategy;
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
        this.handlerChain = buildHandlerChain();
        this.commandProcessor = new CommandProcessor();
        this.responseStrategy = new JSONResponseStrategy();
    }

    @PostMapping("/users")
    public ResponseEntity<?> createUser(@RequestBody UserCreateRequest request) {
        try {
            // Chain of Responsibility로 요청 전처리
            ProcessingContext context = new ProcessingContext(request);
            handlerChain.handle(context);

            if (context.hasErrors()) {
                return responseStrategy.createErrorResponse(context.getErrors());
            }

            // Command 패턴으로 비즈니스 로직 실행
            CreateUserCommand command = new CreateUserCommand(
                context.getValidatedRequest(),
                userService
            );
            CommandResult result = commandProcessor.execute(command);

            // Strategy 패턴으로 응답 생성
            return responseStrategy.createSuccessResponse(result.getData());

        } catch (Exception e) {
            return responseStrategy.createErrorResponse("Internal server error");
        }
    }

    private RequestHandlerChain buildHandlerChain() {
        AuthenticationHandler authHandler = new AuthenticationHandler();
        ValidationHandler validationHandler = new ValidationHandler();
        RateLimitHandler rateLimitHandler = new RateLimitHandler();
        AuditHandler auditHandler = new AuditHandler();

        authHandler.setNext(validationHandler);
        validationHandler.setNext(rateLimitHandler);
        rateLimitHandler.setNext(auditHandler);

        return new RequestHandlerChain(authHandler);
    }
}