Архитектурные паттерны микросервисов: ТОП-10 шаблонов

public class OrderTranslationService {
    private final ExternalOrderSystem externalOrderSystem;
 
    public OrderTranslationService(ExternalOrderSystem externalOrderSystem) {
        this.externalOrderSystem = externalOrderSystem;
    }
 
    public Order translateExternalOrder(ExternalOrder externalOrder) {
        return new Order(
            OrderId.of(externalOrder.getId()),
            CustomerId.of(externalOrder.getCustomerRef()),
            externalOrder.getItems().stream()
                .map(this::translateItem)
                .collect(Collectors.toList()),
            translateStatus(externalOrder.getState())
        );
    }
 
    private OrderItem translateItem(ExternalOrderItem externalItem) {
        return new OrderItem(
            ProductId.of(externalItem.getProductReference()),
            externalItem.getQuantity(),
            Money.of(externalItem.getPrice())
        );
    }
 
    private OrderStatus translateStatus(String externalState) {
        switch (externalState) {
            case "NEW": return OrderStatus.CREATED;
            case "PROCESSING": return OrderStatus.IN_PROGRESS;
            case "FULFILLED": return OrderStatus.COMPLETED;
            case "CANCELED": return OrderStatus.CANCELLED;
            default: throw new IllegalArgumentException("Unknown state: " + externalState);
        }
    }
}

@RestController
@RequestMapping("/orders")
public class OrderController {
    private final OrderService orderService;
    
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }
    
    @PostMapping
    public ResponseEntity<OrderDTO> createOrder(@RequestBody CreateOrderRequest request) {
        Order order = orderService.createOrder(
            request.getCustomerId(), 
            request.getItems()
        );
        return ResponseEntity.ok(OrderMapper.toDTO(order));
    }
    
    @GetMapping("/{orderId}")
    public ResponseEntity<OrderDTO> getOrder(@PathVariable String orderId) {
        Order order = orderService.getOrder(orderId);
        return ResponseEntity.ok(OrderMapper.toDTO(order));
    }
}

public class Order {
    private OrderId id;
    private CustomerId customerId;
    private List<OrderItem> items;
    private OrderStatus status;
    private Money total;
    
    // Конструкторы, геттеры и бизнес-методы
    
    public void addItem(ProductId productId, int quantity, Money price) {
        OrderItem item = new OrderItem(productId, quantity, price);
        items.add(item);
        recalculateTotal();
    }
    
    public void cancel() {
        if (status != OrderStatus.CREATED && status != OrderStatus.PENDING) {
            throw new IllegalStateException("Can't cancel order with status: " + status);
        }
        status = OrderStatus.CANCELLED;
    }
    
    private void recalculateTotal() {
        total = items.stream()
            .map(item -> item.getPrice().multiply(item.getQuantity()))
            .reduce(Money.ZERO, Money::add);
    }
}

@EnableGateway
@SpringBootApplication
public class ApiGatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(ApiGatewayApplication.class, args);
    }
 
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route("product-service", r -> r.path("/products/**")
                        .uri("lb://PRODUCT-SERVICE"))
                .route("order-service", r -> r.path("/orders/**")
                        .uri("lb://ORDER-SERVICE"))
                .route("payment-service", r -> r.path("/payments/[B]")
                        .uri("lb://PAYMENT-SERVICE"))
                .build();
    }
}

@Service
public class OrderEventProcessor {
    private final OrderRepository orderRepository;
 
    public OrderEventProcessor(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }
 
    @StreamListener(Sink.INPUT)
    public void handlePaymentEvent(PaymentProcessedEvent event) {
        Order order = orderRepository.findById(event.getOrderId())
            .orElseThrow(() -> new OrderNotFoundException(event.getOrderId()));
            
        if (event.isSuccessful()) {
            order.markAsPaid();
        } else {
            order.markAsPaymentFailed(event.getFailureReason());
        }
        
        orderRepository.save(order);
    }
}

@Service
public class OrderDetailsService {
    private final OrderClient orderClient;
    private final CustomerClient customerClient;
    private final ShippingClient shippingClient;
 
    public OrderDetailsDTO getOrderDetails(String orderId) {
        // Параллельно запрашиваем данные из разных сервисов
        CompletableFuture<OrderDTO> orderFuture = 
            CompletableFuture.supplyAsync(() -> orderClient.getOrder(orderId));
            
        CompletableFuture<CustomerDTO> customerFuture = orderFuture
            .thenApply(order -> customerClient.getCustomer(order.getCustomerId()));
            
        CompletableFuture<ShippingDTO> shippingFuture = orderFuture
            .thenApply(order -> shippingClient.getShippingInfo(order.getShippingId()));
        
        // Ждем завершения всех запросов и объединяем результаты
        CompletableFuture<OrderDetailsDTO> result = CompletableFuture
            .allOf(orderFuture, customerFuture, shippingFuture)
            .thenApply(v -> createOrderDetails(
                orderFuture.join(), 
                customerFuture.join(), 
                shippingFuture.join()
            ));
            
        return result.join();
    }
    
    private OrderDetailsDTO createOrderDetails(
            OrderDTO order, 
            CustomerDTO customer, 
            ShippingDTO shipping) {
        // Объединяем данные из разных источников
        return new OrderDetailsDTO(order, customer, shipping);
    }
}

@Service
public class OrderProcessOrchestrator {
    private final InventoryService inventoryService;
    private final PaymentService paymentService;
    private final ShippingService shippingService;
    private final OrderService orderService;
 
    public OrderResult processOrder(OrderRequest request) {
        // Шаг 1: Резервируем товары
        InventoryResult inventoryResult = inventoryService.reserveItems(
            request.getItems());
            
        if (!inventoryResult.isSuccess()) {
            return OrderResult.failed("Нехватка товаров на складе");
        }
        
        try {
            // Шаг 2: Обрабатываем платеж
            PaymentResult paymentResult = paymentService.processPayment(
                request.getCustomerId(),
                inventoryResult.getTotalAmount());
                
            if (!paymentResult.isSuccess()) {
                // Если платеж не прошел, отменяем резервацию
                inventoryService.releaseItems(inventoryResult.getReservationId());
                return OrderResult.failed("Ошибка обработки платежа");
            }
            
            // Шаг 3: Создаем заказ на доставку
            ShippingResult shippingResult = shippingService.createShipment(
                request.getCustomerId(),
                request.getDeliveryAddress(),
                inventoryResult.getItems());
                
            if (!shippingResult.isSuccess()) {
                // Если доставка не может быть создана, отменяем предыдущие действия
                paymentService.refundPayment(paymentResult.getTransactionId());
                inventoryService.releaseItems(inventoryResult.getReservationId());
                return OrderResult.failed("Ошибка создания доставки");
            }
            
            // Шаг 4: Создаем заказ
            OrderDTO order = orderService.createOrder(
                request.getCustomerId(),
                inventoryResult.getItems(),
                paymentResult.getTransactionId(),
                shippingResult.getShipmentId());
                
            return OrderResult.success(order);
            
        } catch (Exception e) {
            // В случае любой ошибки отменяем резервацию
            inventoryService.releaseItems(inventoryResult.getReservationId());
            throw e;
        }
    }
}

@RestController
@RequestMapping("/mobile-api/orders")
public class MobileOrderController {
    private final OrderService orderService;
    private final ProductService productService;
    
    @GetMapping
    public List<MobileOrderDTO> getUserOrders(@RequestParam String userId) {
        List<Order> orders = orderService.getOrdersByUserId(userId);
        
        // Возвращаем только нужные для мобильного клиента поля
        return orders.stream()
            .map(order -> {
                MobileOrderDTO dto = new MobileOrderDTO();
                dto.setId(order.getId());
                dto.setDate(order.getCreatedAt());
                dto.setStatus(order.getStatus());
                dto.setTotalAmount(order.getTotalAmount());
                
                // Добавляем только главное изображение первого продукта для превью
                if (!order.getItems().isEmpty()) {
                    OrderItem firstItem = order.getItems().get(0);
                    Product product = productService.getProduct(firstItem.getProductId());
                    dto.setPreviewImage(product.getMainImageUrl());
                    dto.setItemsCount(order.getItems().size());
                }
                
                return dto;
            })
            .collect(Collectors.toList());
    }
}

@Configuration
public class GatewayConfig {
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            // Маршруты для мобильного API
            .route("mobile-products", r -> r.path("/mobile-api/products/**")
                .filters(f -> f
                    .rewritePath("/mobile-api/products/(?<segment>.*)", "/products/${segment}")
                    .addResponseHeader("Cache-Control", "max-age=300")
                    .filter(new MobileProductResponseFilter()))
                .uri("lb://PRODUCT-SERVICE"))
                
            // Маршруты для веб-версии
            .route("web-products", r -> r.path("/web-api/products/**")
                .filters(f -> f
                    .rewritePath("/web-api/products/(?<segment>.*)", "/products/${segment}")
                    .filter(new WebProductResponseFilter()))
                .uri("lb://PRODUCT-SERVICE"))
                
            .build();
    }
}

// Конфигурация базы данных для сервиса заказов
@Configuration
@EnableJpaRepositories(basePackages = "com.example.orders.repository")
@EntityScan(basePackages = "com.example.orders.entity")
public class OrdersDatabaseConfig {
 
    @Primary
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.orders")
    public DataSourceProperties ordersDataSourceProperties() {
        return new DataSourceProperties();
    }
 
    @Primary
    @Bean
    public DataSource ordersDataSource() {
        return ordersDataSourceProperties()
                .initializeDataSourceBuilder()
                .build();
    }
}

// Командная сторона - обработка заказа
@Service
public class OrderCommandService {
    private final OrderRepository orderRepository;
    private final EventPublisher eventPublisher;
 
    public OrderCommandService(OrderRepository orderRepository, EventPublisher eventPublisher) {
        this.orderRepository = orderRepository;
        this.eventPublisher = eventPublisher;
    }
 
    @Transactional
    public String createOrder(CreateOrderCommand command) {
        // Валидация и бизнес-логика
        Order order = new Order(command.getCustomerId(), command.getItems());
        order = orderRepository.save(order);
        
        // Публикация события о создании заказа
        eventPublisher.publish(new OrderCreatedEvent(order));
        
        return order.getId();
    }
}
 
// Запросная сторона - получение данных о заказах
@Service
public class OrderQueryService {
    private final OrderReadRepository readRepository;
 
    public OrderQueryService(OrderReadRepository readRepository) {
        this.readRepository = readRepository;
    }
 
    public OrderDTO getOrderById(String orderId) {
        OrderReadModel orderReadModel = readRepository.findById(orderId)
                .orElseThrow(() -> new OrderNotFoundException(orderId));
        return mapToDTO(orderReadModel);
    }
    
    public List<OrderSummaryDTO> getCustomerOrders(String customerId) {
        return readRepository.findByCustomerId(customerId)
                .stream()
                .map(this::mapToSummaryDTO)
                .collect(Collectors.toList());
    }
}

@Service
public class CreateOrderSaga {
    private final OrderService orderService;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    private final ShippingService shippingService;
 
    @Transactional
    public OrderResult executeCreateOrderSaga(CreateOrderCommand command) {
        // Шаг 1: Создаем заказ в статусе "Ожидание"
        String orderId = orderService.createPendingOrder(command);
        
        try {
            // Шаг 2: Проверяем наличие товаров
            boolean itemsReserved = inventoryService.reserveItems(orderId, command.getItems());
            if (!itemsReserved) {
                // Компенсация: Отменяем заказ
                orderService.cancelOrder(orderId, "Недостаточно товаров на складе");
                return OrderResult.failed("Недостаточно товаров на складе");
            }
            
            // Шаг 3: Обрабатываем платеж
            PaymentResult payment = paymentService.processPayment(
                    orderId, command.getCustomerId(), command.getTotalAmount());
            if (!payment.isSuccessful()) {
                // Компенсация: Освобождаем зарезервированные товары и отменяем заказ
                inventoryService.releaseItems(orderId);
                orderService.cancelOrder(orderId, "Ошибка обработки платежа");
                return OrderResult.failed("Ошибка обработки платежа");
            }
            
            // Шаг 4: Создаем доставку
            ShippingInfo shippingInfo = shippingService.createShipment(
                    orderId, command.getCustomerId(), command.getShippingAddress());
            if (shippingInfo == null) {
                // Компенсация: Возвращаем платеж, освобождаем товары и отменяем заказ
                paymentService.refundPayment(payment.getTransactionId());
                inventoryService.releaseItems(orderId);
                orderService.cancelOrder(orderId, "Невозможно создать доставку");
                return OrderResult.failed("Невозможно создать доставку");
            }
            
            // Шаг 5: Подтверждаем заказ
            orderService.confirmOrder(orderId, payment.getTransactionId(), shippingInfo.getTrackingId());
            
            return OrderResult.success(orderId);
            
        } catch (Exception e) {
            // Общая обработка ошибок с компенсацией
            orderService.cancelOrder(orderId, "Внутренняя ошибка: " + e.getMessage());
            return OrderResult.failed("Внутренняя ошибка");
        }
    }
}

public class Account {
    private String id;
    private BigDecimal balance = BigDecimal.ZERO;
    private List<Event> uncommittedEvents = new ArrayList<>();
    
    public void deposit(BigDecimal amount) {
        apply(new DepositedEvent(id, amount));
    }
    
    public void withdraw(BigDecimal amount) {
        if (balance.compareTo(amount) < 0) {
            throw new InsufficientFundsException();
        }
        apply(new WithdrawnEvent(id, amount));
    }
    
    private void apply(Event event) {
        if (event instanceof DepositedEvent) {
            this.balance = this.balance.add(((DepositedEvent) event).getAmount());
        } else if (event instanceof WithdrawnEvent) {
            this.balance = this.balance.subtract(((WithdrawnEvent) event).getAmount());
        }
        uncommittedEvents.add(event);
    }
    
    public List<Event> getUncommittedEvents() {
        return new ArrayList<>(uncommittedEvents);
    }
    
    public void clearUncommittedEvents() {
        uncommittedEvents.clear();
    }
}

public class AccountRepository {
    private final EventStore eventStore;
    private final SnapshotStore snapshotStore;
    
    public Account findById(String accountId) {
        // Пытаемся найти последний снимок
        Optional<AccountSnapshot> snapshot = snapshotStore.findLatestByAccountId(accountId);
        
        // Определяем, с какого события начинать восстановление
        long fromEventId = snapshot.map(AccountSnapshot::getLastEventId).orElse(0L);
        
        // Загружаем события после снимка
        List<Event> events = eventStore.findByAccountIdAndIdGreaterThan(accountId, fromEventId);
        
        // Создаем объект аккаунта из снимка или с нуля
        Account account = snapshot
                .map(s -> new Account(s.getId(), s.getBalance()))
                .orElse(new Account(accountId));
                
        // Применяем события к аккаунту
        for (Event event : events) {
            account.applyEvent(event);
        }
        
        return account;
    }
    
    public void save(Account account) {
        // Сохраняем новые события
        List<Event> uncommittedEvents = account.getUncommittedEvents();
        eventStore.saveAll(uncommittedEvents);
        
        // Очищаем список непримененных событий
        account.clearUncommittedEvents();
        
        // Периодически создаем новые снимки
        if (shouldCreateSnapshot(account)) {
            snapshotStore.save(new AccountSnapshot(account));
        }
    }
    
    private boolean shouldCreateSnapshot(Account account) {
        // Логика определения необходимости создания снимка
        // Например, каждые 100 событий
        return eventStore.countByAccountId(account.getId()) % 100 == 0;
    }
}

@CircuitBreaker(name = "paymentService", fallbackMethod = "fallbackPayment")
public PaymentResponse processPayment(PaymentRequest request) {
    // Этот вызов будет защищен Circuit Breaker
    return paymentServiceClient.processPayment(request);
}
 
// Метод, который будет вызван, если Circuit Breaker сработает
public PaymentResponse fallbackPayment(PaymentRequest request, Exception e) {
    log.error("Payment service unavailable. Using fallback", e);
    // Возвращаем резервный ответ или выполняем альтернативную логику
    return PaymentResponse.builder()
            .status(PaymentStatus.PENDING)
            .message("Платёж в обработке. Статус будет обновлён позже.")
            .build();
}

// Конфигурация сервера Eureka
@SpringBootApplication
@EnableEurekaServer
public class DiscoveryServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(DiscoveryServerApplication.class, args);
    }
}
 
// Регистрация клиента в Eureka
@SpringBootApplication
@EnableDiscoveryClient
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
    
    // Использование балансера нагрузки для обнаружения других сервисов
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

// Конфигурация Bulkhead
BulkheadConfig config = BulkheadConfig.custom()
    .maxConcurrentCalls(10) // максимум 10 одновременных запросов
    .maxWaitDuration(Duration.ofMillis(500)) // ожидание максимум 500 мс
    .build();
 
// Создание экземпляра Bulkhead для защиты вызовов сервиса заказов
Bulkhead orderServiceBulkhead = Bulkhead.of("orderService", config);
 
// Использование Bulkhead для защиты вызова
Supplier<OrderDTO> decoratedSupplier = Bulkhead.decorateSupplier(
    orderServiceBulkhead, 
    () -> orderServiceClient.getOrder(orderId)
);
 
Try<OrderDTO> result = Try.ofSupplier(decoratedSupplier)
    .recover(BulkheadFullException.class, e -> {
        log.error("Order service overloaded", e);
        return fallbackOrder(orderId);
    });

@Configuration
public class GatewayConfig {
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("payment_route", r -> r.path("/payments/**")
                .filters(f -> f.circuitBreaker(c -> c.setName("paymentCB")
                                .setFallbackUri("forward:/fallback/payment")))
                .uri("lb://payment-service"))
            .build();
    }
}