Facade Pattern w Microservices

Dlaczego Facade Pattern to fundament architektury mikrousług

W 2019 roku architektura mikrousług stała się standardem w enterprise aplikacjach. Ale z wieloma małymi usługami powstaje problem – jak klient ma się komunikować z dziesiątkami różnych API? Wzorzec Facade rozwiązuje to elegancko.

Zamiast zmuszać aplikację kliencką do poznania wszystkich mikrousług, ich endpointów i protokołów komunikacji, udostępniasz jeden przejrzysty interfejs który załatwia wszystko w tle.

Co się nauczysz

Wymagania wstępne

Czym jest wzorzec Facade w mikrousługach

W systemie mikrousług Facade to najczęściej API Gateway, który:
– Agreguje dane z wielu mikrousług
– Transluje protokoły komunikacji
– Zarządza autoryzacją i bezpieczeństwem
– Implementuje circuit breakers i retry logic

Implementacja API Gateway jako Facade

Zacznijmy od prostego przykładu – systemu e-commerce gdzie mamy osobne mikrousługi dla produktów, użytkowników i zamówień:

// Fasada dla systemu e-commerce
@RestController
@RequestMapping("/api/facade")
public class EcommerceFacade {
    
    @Autowired
    private ProductService productService;
    
    @Autowired
    private UserService userService;
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private PaymentService paymentService;
    
    // Endpoint który agreguje dane z wielu mikrousług
    @GetMapping("/user/{userId}/dashboard")
    public UserDashboard getUserDashboard(@PathVariable Long userId) {
        try {
            // Równoczesne wywołania do różnych mikrousług
            CompletableFuture userFuture = 
                CompletableFuture.supplyAsync(() -> userService.getUser(userId));
            
            CompletableFuture> ordersFuture = 
                CompletableFuture.supplyAsync(() -> orderService.getUserOrders(userId));
            
            CompletableFuture> recommendationsFuture = 
                CompletableFuture.supplyAsync(() -> productService.getRecommendations(userId));
            
            // Czekamy na wszystkie odpowiedzi
            User user = userFuture.get();
            List orders = ordersFuture.get();
            List recommendations = recommendationsFuture.get();
            
            // Agregujemy w jeden obiekt
            return UserDashboard.builder()
                .user(user)
                .recentOrders(orders.stream().limit(5).collect(Collectors.toList()))
                .recommendations(recommendations)
                .totalSpent(calculateTotalSpent(orders))
                .build();
                
        } catch (Exception e) {
            // Fallback w przypadku błędu
            return UserDashboard.builder()
                .user(userService.getUser(userId))
                .error("Some data temporarily unavailable")
                .build();
        }
    }
}

Implementacja serwisów komunikacji

// Serwis do komunikacji z mikrousługą produktów
@Service
public class ProductService {
    
    @Autowired
    private RestTemplate restTemplate;
    
    @Value("${microservices.product.url}")
    private String productServiceUrl;
    
    public List getRecommendations(Long userId) {
        try {
            String url = productServiceUrl + "/recommendations?userId=" + userId;
            ResponseEntity response = 
                restTemplate.getForEntity(url, Product[].class);
            
            return Arrays.asList(response.getBody());
        } catch (Exception e) {
            // Circuit breaker pattern - zwróć cache lub pusty result
            return getRecommendationsFromCache(userId);
        }
    }
    
    public Product getProduct(Long productId) {
        String url = productServiceUrl + "/products/" + productId;
        return restTemplate.getForObject(url, Product.class);
    }
    
    private List getRecommendationsFromCache(Long userId) {
        // Implementacja cache'a lub fallback logic
        return Collections.emptyList();
    }
}

// Podobnie dla innych serwisów
@Service
public class OrderService {
    
    @Autowired
    private RestTemplate restTemplate;
    
    @Value("${microservices.order.url}")
    private String orderServiceUrl;
    
    public List getUserOrders(Long userId) {
        try {
            String url = orderServiceUrl + "/orders?userId=" + userId;
            ResponseEntity response = 
                restTemplate.getForEntity(url, Order[].class);
            
            return Arrays.asList(response.getBody());
        } catch (Exception e) {
            // Graceful degradation
            return Collections.emptyList();
        }
    }
}

Złożony przykład – proces składania zamówienia

Zobaczmy jak Facade upraszcza złożony proces biznesowy obejmujący wiele mikrousług:

@PostMapping("/order/complete")
public OrderResult completeOrder(@RequestBody CompleteOrderRequest request) {
    Long userId = request.getUserId();
    Long productId = request.getProductId();
    int quantity = request.getQuantity();
    
    try {
        // Krok 1: Sprawdź dostępność produktu
        Product product = productService.getProduct(productId);
        if (product.getStock() < quantity) {
            return OrderResult.failure("Product not available");
        }
        
        // Krok 2: Sprawdź dane użytkownika i adres
        User user = userService.getUser(userId);
        if (user.getDefaultAddress() == null) {
            return OrderResult.failure("Address required");
        }
        
        // Krok 3: Oblicz koszt z podatkami i dostawą
        BigDecimal totalPrice = calculateTotalPrice(product, quantity, user.getAddress());
        
        // Krok 4: Przetwórz płatność
        PaymentResult paymentResult = paymentService.processPayment(
            user.getPaymentMethod(), totalPrice);
        
        if (!paymentResult.isSuccess()) {
            return OrderResult.failure("Payment failed: " + paymentResult.getError());
        }
        
        // Krok 5: Stwórz zamówienie
        Order order = orderService.createOrder(Order.builder()
            .userId(userId)
            .productId(productId)
            .quantity(quantity)
            .totalPrice(totalPrice)
            .paymentId(paymentResult.getPaymentId())
            .build());
        
        // Krok 6: Zaktualizuj stan magazynu
        productService.updateStock(productId, -quantity);
        
        // Krok 7: Wyślij powiadomienie
        notificationService.sendOrderConfirmation(user.getEmail(), order);
        
        return OrderResult.success(order);
        
    } catch (Exception e) {
        // Rollback w przypadku błędu
        rollbackOrder(request);
        return OrderResult.failure("Order processing failed");
    }
}

Konfiguracja dla resilience

W środowisku mikrousług usługi mogą być czasowo niedostępne. Fasada musi być odporna na błędy:

@Configuration
public class ResilienceConfig {
    
    @Bean
    public RestTemplate restTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        
        // Timeout configuration
        HttpComponentsClientHttpRequestFactory factory = 
            new HttpComponentsClientHttpRequestFactory();
        factory.setConnectTimeout(5000);
        factory.setReadTimeout(10000);
        restTemplate.setRequestFactory(factory);
        
        return restTemplate;
    }
    
    @Bean
    public CircuitBreaker circuitBreaker() {
        return CircuitBreaker.ofDefaults("microservices");
    }
}

// Użycie Circuit Breaker w serwisie
@Service
public class ResilientProductService {
    
    @Autowired
    private CircuitBreaker circuitBreaker;
    
    @Autowired
    private RestTemplate restTemplate;
    
    public List getRecommendations(Long userId) {
        Supplier> supplier = CircuitBreaker
            .decorateSupplier(circuitBreaker, () -> {
                String url = productServiceUrl + "/recommendations?userId=" + userId;
                ResponseEntity response = 
                    restTemplate.getForEntity(url, Product[].class);
                return Arrays.asList(response.getBody());
            });
        
        try {
            return supplier.get();
        } catch (Exception e) {
            // Fallback do cached data
            return getCachedRecommendations(userId);
        }
    }
}

Zalety wzorca w mikrousługach

1. Uproszczenie dla klientów

2. Performance przez agregację

3. Ewolucja architektury

Gdy zmienisz wewnętrzną strukturę mikrousług (połączysz dwie usługi, podzielisz jedną na trzy), facade może ukryć te zmiany przed klientami, zachowując backward compatibility.

Typowe pułapki i rozwiązania

Przydatne zasoby:

• Spring Cloud Gateway Documentation
• Netflix Zuul API Gateway
• API Gateway Pattern - Microservices.io
• Resilience4j - Circuit Breaker Library

Wzorzec Facade w mikrousługach to nie tylko pattern, to konieczność. W 2019 roku każda duża organizacja używa API Gateway jako fasady do swoich systemów. Bez tego klienty mobilne robiłyby dziesiątki wywołań, a każda zmiana w backend wymagałaby aktualizacji wszystkich aplikacji klienckich.

Jak widzisz zastosowanie wzorca Facade w swoich projektach? Jakie największe wyzwania napotkałeś przy implementacji API Gateway? Podziel się doświadczeniami w komentarzach!