Создание микросервисов с Domain-Driven Design

// Пример объекта-значения (Value Object) на Java
public final class Money {
    private final BigDecimal amount;
    private final Currency currency;
    
    public Money(BigDecimal amount, Currency currency) {
        this.amount = amount;
        this.currency = currency;
    }
    
    // Вместо изменения создаём новый объект
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new IllegalArgumentException("Cannot add different currencies");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }
    
    // Геттеры...
}

// Пример агрегата на Java
public class Order {
    private OrderId id;
    private Customer customer;
    private List<OrderLine> orderLines = new ArrayList<>();
    private Money totalAmount;
    private Address shippingAddress;
    
    // Защищаем инварианты агрегата
    public void addOrderLine(Product product, int quantity) {
        OrderLine line = new OrderLine(product, quantity);
        orderLines.add(line);
        
        // Пересчитываем общую сумму
        totalAmount = calculateTotalAmount();
    }
    
    private Money calculateTotalAmount() {
        // Логика расчёта...
    }
    
    // Другие методы...
}

// Слой антикоррупции для интеграции с устаревшей системой
public class LegacyInventoryAdapter implements InventoryService {
    private LegacyInventoryClient legacyClient;
    
    @Override
    public InventoryStatus checkAvailability(ProductId productId, int quantity) {
        // Трансляция данных из нашей модели в формат устаревшей системы
        String legacyProductCode = convertToLegacyCode(productId);
        
        // Вызов API устаревшей системы
        RawInventoryData rawData = legacyClient.checkStock(legacyProductCode);
        
        // Трансляция ответа обратно в понятия нашей модели
        return translateLegacyResponse(rawData, quantity);
    }
    
    // Методы трансляции...
}

// Пример доменного события
public class OrderPlacedEvent implements DomainEvent {
    private final OrderId orderId;
    private final CustomerId customerId;
    private final Money totalAmount;
    private final LocalDateTime placedAt;
    
    // Конструктор, геттеры...
}
 
// Сервис, публикующий события
public class OrderService {
    private final OrderRepository repository;
    private final EventPublisher eventPublisher;
    
    public Order placeOrder(PlaceOrderCommand command) {
        // Создание и сохранение заказа...
        Order order = new Order(command.getCustomerId(), command.getItems());
        repository.save(order);
        
        // Публикация события
        eventPublisher.publish(new OrderPlacedEvent(
            order.getId(), 
            order.getCustomerId(),
            order.getTotalAmount(),
            LocalDateTime.now()
        ));
        
        return order;
    }
}

@Entity
@Table(name = "orders")
public class Order {
    @Id
    private UUID id;
    
    @Enumerated(EnumType.STRING)
    private OrderStatus status;
    
    @Embedded
    private CustomerId customerId;
    
    @ElementCollection
    private Set<OrderItem> items = new HashSet<>();
    
    @Embedded
    private ShippingAddress shippingAddress;
    
    @Embedded
    private Money totalAmount;
    
    // Конструктор защищен для обеспечения инвариантов
    protected Order() {}
    
    // Фабричный метод для создания нового заказа
    public static Order create(CustomerId customerId, ShippingAddress address) {
        Order order = new Order();
        order.id = UUID.randomUUID();
        order.status = OrderStatus.CREATED;
        order.customerId = customerId;
        order.shippingAddress = address;
        order.totalAmount = Money.zero(Currency.getInstance("USD"));
        
        // Публикуем доменное событие
        DomainEvents.publish(new OrderCreatedEvent(order.id, customerId));
        
        return order;
    }
    
    // Бизнес-метод добавления товара
    public void addItem(ProductId productId, int quantity, Money price) {
        if (status != OrderStatus.CREATED) {
            throw new DomainException("Cannot modify confirmed order");
        }
        
        OrderItem item = new OrderItem(productId, quantity, price);
        items.add(item);
        recalculateTotal();
    }
    
    // Бизнес-метод подтверждения заказа
    public void confirm() {
        if (items.isEmpty()) {
            throw new DomainException("Cannot confirm empty order");
        }
        
        status = OrderStatus.CONFIRMED;
        
        // Публикуем событие подтверждения
        DomainEvents.publish(new OrderConfirmedEvent(id, totalAmount));
    }
    
    private void recalculateTotal() {
        totalAmount = items.stream()
            .map(item -> item.getPrice().multiply(item.getQuantity()))
            .reduce(Money.zero(Currency.getInstance("USD")), Money::add);
    }
    
    // Геттеры, но не сеттеры - для инкапсуляции
}

// Публикация события
@Service
public class OrderEventPublisher {
    private final KafkaTemplate<String, DomainEvent> kafkaTemplate;
    
    @Autowired
    public OrderEventPublisher(KafkaTemplate<String, DomainEvent> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }
    
    public void publish(DomainEvent event) {
        kafkaTemplate.send("domain-events", event.getAggregateId().toString(), event);
    }
}
 
// Обработка события в другом сервисе
@Service
public class ShipmentService {
    @KafkaListener(topics = "domain-events")
    public void handleDomainEvent(DomainEvent event) {
        if (event instanceof OrderConfirmedEvent) {
            OrderConfirmedEvent confirmedEvent = (OrderConfirmedEvent) event;
            createShipment(confirmedEvent.getOrderId(), confirmedEvent.getAddress());
        }
    }
    
    private void createShipment(OrderId orderId, Address address) {
        // Логика создания отгрузки
    }
}

@RestController
@RequestMapping("/api/orders")
public class OrderApiGateway {
    private final OrderService orderService;
    private final ProductCatalogClient productClient;
    private final CustomerClient customerClient;
    
    @GetMapping("/{orderId}")
    public OrderDetailsDTO getOrderDetails(@PathVariable UUID orderId) {
        // Получаем основные данные заказа
        OrderDTO order = orderService.getOrderById(orderId);
        
        // Обогащаем данными о продуктах
        List<ProductDTO> products = order.getItems().stream()
            .map(item -> productClient.getProductDetails(item.getProductId()))
            .collect(Collectors.toList());
        
        // Получаем информацию о клиенте
        CustomerDTO customer = customerClient.getCustomer(order.getCustomerId());
        
        // Собираем агрегированный DTO для клиента
        return new OrderDetailsDTO(order, products, customer);
    }
}

@Saga
public class OrderProcessingSaga {
    @Autowired
    private CommandGateway commandGateway;
    
    @StartSaga
    @SagaEventHandler(associationProperty = "orderId")
    public void handle(OrderConfirmedEvent event) {
        // Шаг 1: Резервируем товары
        commandGateway.send(new ReserveInventoryCommand(
            event.getOrderId(),
            event.getItems()
        ));
    }
    
    @SagaEventHandler(associationProperty = "orderId")
    public void handle(InventoryReservedEvent event) {
        // Шаг 2: Инициируем оплату
        commandGateway.send(new ProcessPaymentCommand(
            event.getOrderId(),
            event.getTotalAmount()
        ));
    }
    
    @SagaEventHandler(associationProperty = "orderId")
    public void handle(PaymentProcessedEvent event) {
        // Шаг 3: Создаем доставку
        commandGateway.send(new CreateShippingCommand(
            event.getOrderId(),
            event.getShippingAddress()
        ));
    }
    
    @SagaEventHandler(associationProperty = "orderId")
    public void handle(PaymentFailedEvent event) {
        // Компенсирующая транзакция при ошибке оплаты
        commandGateway.send(new ReleaseInventoryCommand(
            event.getOrderId()
        ));
        commandGateway.send(new CancelOrderCommand(
            event.getOrderId(),
            "Payment failed: " + event.getReason()
        ));
        // Завершаем сагу
        SagaLifecycle.end();
    }
}

// Команда - запись
@CommandHandler
public class PolicyApplicationHandler {
    @Autowired
    private PolicyRepository policyRepository;
    
    public void handle(CreatePolicyCommand command) {
        // Сложная бизнес-логика создания полиса
        Policy policy = Policy.create(
            command.getClientId(),
            command.getCoverageType(),
            command.getPremiumAmount()
        );
        
        // Проверки и обогащение полиса бизнес-правилами
        policyRepository.save(policy);
    }
}
 
// Запрос - чтение
@RestController
@RequestMapping("/policies")
public class PolicyQueryController {
    @Autowired
    private PolicyViewRepository viewRepository;
    
    @GetMapping("/client/{clientId}")
    public List<PolicySummaryDTO> getPoliciesForClient(@PathVariable String clientId) {
        // Простой и оптимизированный запрос к проекции
        return viewRepository.findByClientId(clientId);
    }
}

@Component
public class ProductCatalogClient {
    @HystrixCommand(fallbackMethod = "getDefaultProduct",
                  commandProperties = {
                      @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),
                      @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50"),
                      @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "5000")
                  })
    public ProductDTO getProductDetails(UUID productId) {
        // Вызов микросервиса каталога товаров
        return restTemplate.getForObject("/products/" + productId, ProductDTO.class);
    }
    
    public ProductDTO getDefaultProduct(UUID productId) {
        // Запасной вариант, когда сервис недоступен
        return new ProductDTO(productId, "N/A", "Продукт временно недоступен", BigDecimal.ZERO);
    }
}

@Service
public class PaymentProcessor {
    @Autowired
    private TransactionRepository repository;
    
    @Transactional
    public void processPayment(PaymentCommand command) {
        // Проверяем, не обработан ли уже этот платёж
        if (repository.existsByTransactionId(command.getTransactionId())) {
            log.info("Payment already processed: {}", command.getTransactionId());
            return;
        }
        
        // Выполняем фактическое списание средств
        Account account = accountRepository.findById(command.getAccountId());
        account.debit(command.getAmount());
        accountRepository.save(account);
        
        // Сохраняем идентификатор транзакции
        Transaction tx = new Transaction(command.getTransactionId(), command.getAccountId(), command.getAmount());
        repository.save(tx);
    }
}

@Aggregate
public class OrderAggregate {
    @AggregateIdentifier
    private String id;
    private OrderStatus status;
    
    @CommandHandler
    public OrderAggregate(CreateOrderCommand cmd) {
        // Валидация команды
        if (cmd.getItems().isEmpty()) {
            throw new IllegalArgumentException("Order cannot be empty");
        }
        
        // Применяем событие
        apply(new OrderCreatedEvent(cmd.getOrderId(), cmd.getCustomerId(), cmd.getItems()));
    }
    
    @EventSourcingHandler
    public void on(OrderCreatedEvent event) {
        this.id = event.getOrderId();
        this.status = OrderStatus.CREATED;
    }
    
    @CommandHandler
    public void handle(ConfirmOrderCommand cmd) {
        if (status != OrderStatus.CREATED) {
            throw new IllegalStateException("Cannot confirm order in status " + status);
        }
        
        apply(new OrderConfirmedEvent(id));
    }
    
    @EventSourcingHandler
    public void on(OrderConfirmedEvent event) {
        this.status = OrderStatus.CONFIRMED;
    }
}

com.example.orderservice/
  ├── domain/          # Доменная модель
  │   ├── Order.java
  │   ├── OrderItem.java
  │   └── events/      # Доменные события
  ├── application/     # Прикладной слой
  │   ├── commands/    # Команды и их обработчики
  │   └── queries/     # Запросы и их обработчики
  ├── infrastructure/  # Инфраструктурный слой
  │   ├── persistence/ # Репозитории
  │   └── messaging/   # Интеграция с брокером сообщений
  └── api/             # API слой
      ├── rest/        # REST контроллеры
      └── dto/         # DTO для внешнего мира

@SpringBootTest
@AutoConfigureWireMock(port = 0)
public class ProductServiceContractTest {
    @Autowired
    private ProductClient productClient;
    
    @Test
    public void shouldReturnProductWhenExists() {
        // Настраиваем мок сервиса каталога
        stubFor(get(urlPathEqualTo("/products/123"))
            .willReturn(aResponse()
                .withStatus(200)
                .withHeader("Content-Type", "application/json")
                .withBody("{\"id\":\"123\",\"name\":\"Laptop\",\"price\":999.99}")));
        
        // Вызываем клиент
        ProductDTO product = productClient.getProduct("123");
        
        // Проверяем результат
        assertEquals("123", product.getId());
        assertEquals("Laptop", product.getName());
        assertEquals(new BigDecimal("999.99"), product.getPrice());
    }
}

@Service
public class OrderCompletionSaga {
  private final KafkaTemplate<String, Object> kafkaTemplate;
  private final PaymentClient paymentClient;
  
  public void completeOrder(Order order) {
      try {
          // Попытка списать деньги
          paymentClient.chargeMoney(order.getCustomerId(), order.getTotalAmount());
          
          // Если успешно, публикуем событие об успешном заказе
          kafkaTemplate.send("orders", "completed", new OrderCompletedEvent(order.getId()));
      } catch (Exception e) {
          // В случае сбоя публикуем компенсирующее событие
          kafkaTemplate.send("orders", "failed", new OrderFailedEvent(order.getId(), e.getMessage()));
      }
  }
}