200줄 메서드를 파사드 패턴으로 정복하기

@Synchronized
public void syncExternalOrder(OrderSyncRequest req) throws SystemException {
    try {
        // 1. 외부 API 호출
        List<Map<String, Object>> res = callExternalApi(API_PATH, req);
        List<ExternalOrder> orders = convertToOrders(res);

        if (!CollectionUtils.isEmpty(orders)) {
            // 2. 연관 데이터 조회
            req.setResourceId(orders.get(0).getResourceId());
            Optional<Resource> resourceOpt = resourceRepository.findByExternalId(req.getResourceId());
            if (resourceOpt.isEmpty() || resourceOpt.get().getStatus().equals("INACTIVE")) {
                throw new SystemException(ErrorCode.RESOURCE_NOT_FOUND);
            }

            // 3. 사이트 조회
            Optional<Site> siteOpt = siteRepository.findByExternalId(orders.get(0).getSiteCode());
            Site site = siteOpt.orElseThrow(() -> new SystemException(ErrorCode.SITE_NOT_FOUND));

            // 4. 민감정보 복호화 (6개 필드)
            orders.get(0).setAccountNo(decrypt(orders.get(0).getAccountNo()));
            orders.get(0).setMonthlyAccountNo(decrypt(orders.get(0).getMonthlyAccountNo()));
            orders.get(0).setAccountName(decrypt(orders.get(0).getAccountName()));
            orders.get(0).setBankName(decrypt(orders.get(0).getBankName()));
            orders.get(0).setMonthlyBankName(decrypt(orders.get(0).getMonthlyBankName()));
            orders.get(0).setMonthlyAccountName(decrypt(orders.get(0).getMonthlyAccountName()));

            // 5. Order 엔티티 생성
            Order order = new Order(orders.get(0), site);

            // 6. 레거시 시스템 매핑 처리 (중첩 if 3단계)
            if (StringUtils.isNotEmpty(orders.get(0).getLegacyOrderId()) &&
                    !orders.get(0).getLegacyOrderId().equalsIgnoreCase("0")) {
                Optional<Order> existOrder = orderRepository.findByGroupId(orders.get(0).getGroupId());
                if (existOrder.isPresent()) {
                    order.setId(existOrder.get().getId());
                    order.setMigrated(true);
                } else {
                    Optional<Order> legacyOrder = orderRepository.findByLegacyId(orders.get(0).getLegacyOrderId());
                    if (legacyOrder.isPresent()) {
                        order.setId(legacyOrder.get().getId());
                        order.setMigrated(true);
                    } else {
                        throw new SystemException(ErrorCode.ORDER_NOT_FOUND);
                    }
                }
            }

            // 7~16. 계속 이어짐... (총 200줄)
            // - 보증금 계산 (for문)
            // - 주문 상태 업데이트 (복잡한 if)
            // - 버전 비교 및 데이터 보정
            // - 특수 계약 타입 처리
            // - DB 저장
            // - 프리 기간 처리
            // - 중개 정보 처리
        }
    } catch (SystemException e) {
        log.error("System error: {}", e);
        throw new SystemException(e.getErrorCode());
    } catch (Exception e) {
        log.error("Unexpected error: {}", e);
        throw new SystemException(ErrorCode.BAD_REQUEST);
    }
}

// 복잡한 서브시스템들
class SecurityService { void decrypt(String data) { ... } }
class ValidationService { void validate(Order order) { ... } }
class NotificationService { void sendNotification() { ... } }
class DatabaseService { void save(Order order) { ... } }

// 전통적 파사드 - 별도 클래스
class OrderFacade {
    private SecurityService security;
    private ValidationService validator;
    private NotificationService notifier;
    private DatabaseService database;

    public void processOrder(Order order) {
        security.decrypt(order);
        validator.validate(order);
        database.save(order);
        notifier.sendNotification();
    }
}

// Bad - 추상화 수준이 섞여 있음 (저수준 + 고수준)
public void processOrder() {
    String decrypted = aesEncrypt.aesDecode(data, key);  // 저수준
    validateOrder(order);                                 // 고수준
    order.setStatus("COMPLETED");                         // 저수준
    orderRepository.save(order);                          // 고수준
}

// Good - 파사드 패턴 (모두 고수준)
public void processOrder() {
    decryptSensitiveData();    // 고수준
    validateOrder();           // 고수준
    updateOrderStatus();       // 고수준
    saveOrder();               // 고수준
}

@Synchronized
public void syncExternalOrder(OrderSyncRequest req) throws SystemException {
    try {
        List<Map<String, Object>> res = callExternalApi(API_PATH, req);
        List<ExternalOrder> orders = convertToOrders(res);

        if (CollectionUtils.isEmpty(orders))
            return;

        ExternalOrder externalOrder = orders.get(0);
        req.setResourceId(externalOrder.getResourceId());

        Resource resource = findValidResource(req.getResourceId());
        Site site = findSite(externalOrder.getSiteCode());

        // 민감정보 복호화
        decryptSensitiveFields(externalOrder);

        Order order = new Order(externalOrder, site, resource);

        // 레거시 매핑
        mapLegacyOrder(externalOrder, order);

        // 리소스 ID 설정
        order.setResourceId(resource.getId());

        // 보증금 계산
        computeDepositAmounts(externalOrder, order);

        Optional<Order> existingOrder = orderRepository.findById(order.getId());

        // 주문 상태 업데이트
        updateOrderState(order, existingOrder);

        // 시작일 보정
        adjustStartDate(order, existingOrder);

        // 버전 비교 및 데이터 조정
        existingOrder.ifPresent(existing -> adjustOrderDetails(order, existing));

        // 특수 계약 처리
        handleSpecialLeaseType(order, externalOrder);

        // 주문 저장
        saveOrder(order, externalOrder);

        // 연관 데이터 동기화
        syncRelatedData(req);

        // 프리 기간 처리
        processFreeSchedules(externalOrder, order);

        // 중개 정보 처리
        processBrokerage(req, order.getId(), externalOrder);

    } catch (SystemException e) {
        log.error("System error: {}", e);
        throw new SystemException(e.getErrorCode());
    } catch (Exception e) {
        log.error("Unexpected error: {}", e);
        throw new SystemException(ErrorCode.BAD_REQUEST);
    }
}

graph TD
    A[syncExternalOrder<br/>파사드] --> B[decryptSensitiveFields<br/>보안]
    A --> C[computeDepositAmounts<br/>비즈니스 로직]
    A --> D[updateOrderState<br/>상태 관리]
    A --> E[adjustOrderDetails<br/>데이터 조정]
    A --> F[processFreeSchedules<br/>스케줄 처리]
    A --> G[processBrokerage<br/>중개 정보]

    style A fill:#e3f2fd
    style B fill:#fff3e0
    style C fill:#fff3e0
    style D fill:#fff3e0
    style E fill:#fff3e0
    style F fill:#fff3e0
    style G fill:#fff3e0

// 별도 Facade 클래스
public class OrderSyncFacade {
    private final ExternalApiService api;
    private final ValidationService validation;
    private final TransformService transform;
    // ...
}

// 같은 클래스 내 private 메서드 분리
public class OrderService {
    private void fetchExternalData() {}
    private void validateOrder() {}
    // ...
}

// 이 정도는 분리 안 해도 됨
public void simpleMethod() {
    validate();
    process();
    save();
}