Роль Domain-Driven Design в современных архитектурах

public class Order {
    private Long id;
    private List<OrderItem> items;
    private Customer customer;
    private BigDecimal totalAmount;
    
    // Геттеры и сеттеры для всех полей
}
 
public class OrderService {
    public void processOrder(Order order) {
        // Вся бизнес-логика здесь
        calculateTotal(order);
        validateOrder(order);
        saveOrder(order);
        notifyCustomer(order);
    }
}

public class Order {
    private OrderId id;
    private Set<OrderItem> items;
    private CustomerId customerId;
    private OrderStatus status;
    
    public void addItem(Product product, int quantity) {
        validateProductAvailability(product, quantity);
        OrderItem item = new OrderItem(product.getId(), quantity, product.getCurrentPrice());
        this.items.add(item);
    }
    
    public void place() {
        validateMinimumOrderAmount();
        this.status = OrderStatus.PLACED;
        DomainEvents.publish(new OrderPlacedEvent(this.id));
    }
    
    private void validateMinimumOrderAmount() {
        if (calculateTotal().isLessThan(Money.of(10, Currency.USD))) {
            throw new MinimumOrderAmountNotMetException();
        }
    }
    
    public Money calculateTotal() {
        return items.stream()
                .map(OrderItem::calculatePrice)
                .reduce(Money.zero(Currency.USD), Money::add);
    }
}

// Вместо
public class PaymentProcessor {
    public void processTransaction(Transaction transaction) { ... }
}
 
// Мы писали
public class ClearingSystem {
    public void processPosting(Posting posting) { ... }
}

// Доменный сервис - содержит только бизнес-логику
public class OrderDiscountService {
    public Money calculateDiscount(Order order, CustomerLoyaltyLevel loyaltyLevel) {
        // Чистая доменная логика без внешних зависимостей
        if (order.containsPromotionalItems() && loyaltyLevel.isVIP()) {
            return order.calculateTotal().multiply(0.15);
        }
        // ... другие бизнес-правила
        return Money.zero(order.getCurrency());
    }
}
 
// Сервис приложения - оркестрирует бизнес-процесс
public class OrderApplicationService {
    private final OrderRepository orderRepository;
    private final CustomerRepository customerRepository;
    private final OrderDiscountService discountService;
    private final PaymentGateway paymentGateway;
    private final EventPublisher eventPublisher;
    
    public void placeOrder(PlaceOrderCommand cmd) {
        Order order = orderRepository.findById(cmd.getOrderId());
        Customer customer = customerRepository.findById(cmd.getCustomerId());
        
        Money discount = discountService.calculateDiscount(order, customer.getLoyaltyLevel());
        order.applyDiscount(discount);
        
        order.place();
        orderRepository.save(order);
        
        paymentGateway.requestPayment(order);
        eventPublisher.publish(new OrderPlacedEvent(order.getId()));
    }
}

public class LaboratorySystemAdapter {
    private final LegacyLabApi legacyApi;
    
    public void sendPatientData(Patient patient) {
        // Трансляция нашей модели в формат унаследованной системы
        LegacyPatientDto legacyPatient = new LegacyPatientDto();
        legacyPatient.setPatientCode(patient.getId().toString());
        legacyPatient.setFirstName(patient.getName().getFirstName());
        legacyPatient.setLastName(patient.getName().getLastName());
        // Переводим нашу медкарту в их формат
        legacyPatient.setRecordNum(formatMedicalRecordId(patient.getMedicalRecord().getId()));
        
        legacyApi.registerPatient(legacyPatient);
    }
    
    public List<TestResult> fetchTestResults(PatientId patientId) {
        // Получаем данные из легаси системы и транслируем в нашу модель
        String legacyPatientCode = patientId.toString();
        List<LegacyTestResultDto> legacyResults = legacyApi.getResults(legacyPatientCode);
        
        return legacyResults.stream()
                .map(this::convertToTestResult)
                .collect(Collectors.toList());
    }
    
    private TestResult convertToTestResult(LegacyTestResultDto dto) {
        // Трансляция из их модели в нашу
        // ...
    }
}

public class Account {
    private AccountId id;
    private Money balance;
    private CustomerId ownerId;
    private Set<Transaction> transactions;
    private AccountStatus status;
    
    // Корень агрегата контролирует все изменения
    public void deposit(Money amount, TransactionReference reference) {
        validateAccountIsOperational();
        Transaction transaction = new Transaction(
            TransactionId.generate(), 
            amount, 
            TransactionType.DEPOSIT, 
            reference,
            LocalDateTime.now()
        );
        this.transactions.add(transaction);
        this.balance = this.balance.add(amount);
        DomainEvents.publish(new AccountCredited(this.id, amount, reference));
    }
    
    public void withdraw(Money amount, TransactionReference reference) {
        validateAccountIsOperational();
        ensureSufficientBalance(amount);
        
        Transaction transaction = new Transaction(
            TransactionId.generate(), 
            amount, 
            TransactionType.WITHDRAWAL, 
            reference,
            LocalDateTime.now()
        );
        this.transactions.add(transaction);
        this.balance = this.balance.subtract(amount);
        DomainEvents.publish(new AccountDebited(this.id, amount, reference));
    }
    
    private void ensureSufficientBalance(Money amount) {
        if (balance.isLessThan(amount)) {
            throw new InsufficientBalanceException(id, balance, amount);
        }
    }
    
    private void validateAccountIsOperational() {
        if (status != AccountStatus.ACTIVE) {
            throw new AccountNotOperationalException(id, status);
        }
    }
    
    // Остальные методы...
}

public final class Money {
    private final BigDecimal amount;
    private final Currency currency;
    
    // Конструктор и фабричные методы
    private Money(BigDecimal amount, Currency currency) {
        this.amount = amount.setScale(currency.getDefaultFractionDigits(), RoundingMode.HALF_EVEN);
        this.currency = currency;
    }
    
    public static Money of(BigDecimal amount, Currency currency) {
        return new Money(amount, currency);
    }
    
    public static Money of(double amount, Currency currency) {
        return new Money(BigDecimal.valueOf(amount), currency);
    }
    
    public static Money zero(Currency currency) {
        return new Money(BigDecimal.ZERO, currency);
    }
    
    // Бизнес-операции, всегда возвращают новый объект
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new CurrencyMismatchException(this.currency, other.currency);
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }
    
    public Money subtract(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new CurrencyMismatchException(this.currency, other.currency);
        }
        return new Money(this.amount.subtract(other.amount), this.currency);
    }
    
    public Money multiply(double multiplier) {
        return new Money(this.amount.multiply(BigDecimal.valueOf(multiplier)), this.currency);
    }
    
    public boolean isLessThan(Money other) {
        ensureSameCurrency(other);
        return this.amount.compareTo(other.amount) < 0;
    }
    
    private void ensureSameCurrency(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new CurrencyMismatchException(this.currency, other.currency);
        }
    }
    
    // Equals, HashCode и toString
}

public interface AccountRepository {
    Account findById(AccountId id);
    void save(Account account);
    void delete(Account account);
    AccountCollection findByOwner(CustomerId ownerId);
}

@Repository
public class JpaAccountRepository implements AccountRepository {
    private final SpringAccountRepository springRepo;
    private final AccountMapper mapper;
    
    public JpaAccountRepository(SpringAccountRepository springRepo, AccountMapper mapper) {
        this.springRepo = springRepo;
        this.mapper = mapper;
    }
    
    @Override
    public Account findById(AccountId id) {
        return springRepo.findById(id.getValue())
                .map(mapper::toDomain)
                .orElseThrow(() -> new AccountNotFoundException(id));
    }
    
    @Override
    public void save(Account account) {
        AccountJpaEntity entity = mapper.toEntity(account);
        springRepo.save(entity);
        // Очистка кэша событий после сохранения
        DomainEvents.clearEventsFor(account);
    }
    
    // Остальные методы...
}

public class AccountCredited implements DomainEvent {
    private final AccountId accountId;
    private final Money amount;
    private final TransactionReference reference;
    private final LocalDateTime occurredAt;
    
    public AccountCredited(AccountId accountId, Money amount, TransactionReference reference) {
        this.accountId = accountId;
        this.amount = amount;
        this.reference = reference;
        this.occurredAt = LocalDateTime.now();
    }
    
    // Геттеры...
}

public class DomainEvents {
    private static final ThreadLocal<List<DomainEvent>> events = ThreadLocal.withInitial(ArrayList::new);
    
    public static void publish(DomainEvent event) {
        events.get().add(event);
    }
    
    public static List<DomainEvent> allEvents() {
        return Collections.unmodifiableList(events.get());
    }
    
    public static void clearEvents() {
        events.get().clear();
    }
    
    public static void clearEventsFor(Object aggregateRoot) {
        // Если у вас есть механизм связывания событий с агрегатами
    }
}

public interface Specification<T> {
    boolean isSatisfiedBy(T candidate);
    
    default Specification<T> and(Specification<T> other) {
        return candidate -> this.isSatisfiedBy(candidate) && other.isSatisfiedBy(candidate);
    }
    
    default Specification<T> or(Specification<T> other) {
        return candidate -> this.isSatisfiedBy(candidate) || other.isSatisfiedBy(candidate);
    }
    
    default Specification<T> not() {
        return candidate -> !this.isSatisfiedBy(candidate);
    }
}

public class ActiveAccountSpecification implements Specification<Account> {
    @Override
    public boolean isSatisfiedBy(Account account) {
        return account.getStatus() == AccountStatus.ACTIVE;
    }
}
 
public class MinimumBalanceSpecification implements Specification<Account> {
    private final Money minimumBalance;
    
    public MinimumBalanceSpecification(Money minimumBalance) {
        this.minimumBalance = minimumBalance;
    }
    
    @Override
    public boolean isSatisfiedBy(Account account) {
        return !account.getBalance().isLessThan(minimumBalance);
    }
}

Specification<Account> eligibleForCreditSpec = new ActiveAccountSpecification()
        .and(new MinimumBalanceSpecification(Money.of(1000, Currency.getInstance("USD"))))
        .and(new AccountAgeSpecification(Period.ofMonths(6)));
 
List<Account> eligibleAccounts = accountRepository.findAll().stream()
        .filter(eligibleForCreditSpec::isSatisfiedBy)
        .collect(Collectors.toList());

public interface JpaSpecification<T> extends Specification<T> {
    Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder builder);
}

// Ключевые индикаторы, что функциональность заслуживает отдельного микросервиса:
 
// 1. Отдельная доменная модель с уникальными понятиями
public class Route {
private RouteId id;
private List<Waypoint> waypoints;
private Vehicle assignedVehicle;
private RouteStatus status;
 
public void optimize() {
    // Сложная бизнес-логика оптимизации маршрута
    // Не имеет отношения к другим контекстам
}
}
 
// 2. Собственная команда и жизненный цикл
// 3. Отдельная база данных или схема
// 4. Коммуникация с другими сервисами через события
public class RouteOptimized implements DomainEvent {
private final RouteId routeId;
private final List<WaypointDto> optimizedWaypoints;
private final Duration estimatedDuration;
private final Distance totalDistance;
private final LocalDateTime occurredAt;
}

// Команда для записи - богатая доменная модель
public class Account {
private AccountId id;
private List<Event> changes = new ArrayList<>();
 
public void deposit(Money amount) {
    apply(new MoneyDepositedEvent(id, amount));
}
 
public void withdraw(Money amount) {
    if (calculateBalance().isLessThan(amount)) {
        throw new InsufficientFundsException();
    }
    apply(new MoneyWithdrawnEvent(id, amount));
}
 
private void apply(Event event) {
    changes.add(event);
    applyEvent(event);
}
 
private void applyEvent(Event event) {
    if (event instanceof MoneyDepositedEvent) {
        handleMoneyDeposited((MoneyDepositedEvent) event);
    } else if (event instanceof MoneyWithdrawnEvent) {
        handleMoneyWithdrawn((MoneyWithdrawnEvent) event);
    }
    // ...
}
 
private Money calculateBalance() {
    // Пересчитываем баланс из истории событий
}
}
 
// Запросы - оптимизированная read-модель
@Service
public class AccountQueryService {
private final JdbcTemplate jdbc;
 
public AccountBalanceDto getBalance(String accountId) {
    return jdbc.queryForObject(
        "SELECT account_id, balance, currency FROM account_balances WHERE account_id = ?",
        new Object[]{accountId},
        (rs, rowNum) -> new AccountBalanceDto(
            rs.getString("account_id"),
            rs.getBigDecimal("balance"),
            rs.getString("currency")
        )
    );
}
}

// Порт - интерфейс к внешнему миру
public interface BillingSystem {
void chargeCustomer(CustomerId customerId, Money amount, ChargeDescription description);
CustomerBalance getBalance(CustomerId customerId);
}
 
// Адаптер - конкретная реализация
@Service
public class SapBillingAdapter implements BillingSystem {
private final SapClient sapClient;
 
@Override
public void chargeCustomer(CustomerId customerId, Money amount, ChargeDescription description) {
    SapChargeRequest request = new SapChargeRequest();
    request.setCustomerNumber(customerId.toString());
    request.setAmount(amount.getAmount().doubleValue());
    request.setCurrency(amount.getCurrency().getCurrencyCode());
    request.setDescription(description.getText());
    
    sapClient.executeCharge(request);
}
 
@Override
public CustomerBalance getBalance(CustomerId customerId) {
    SapBalanceResponse response = sapClient.getCustomerBalance(customerId.toString());
    return new CustomerBalance(
        Money.of(response.getBalanceAmount(), Currency.getInstance(response.getCurrencyCode())),
        response.getLastUpdate()
    );
}
}
 
// Сервис домена, использующий порт, не зависит от конкретной реализации
public class ServiceActivationService {
private final BillingSystem billingSystem;
 
public ServiceActivationService(BillingSystem billingSystem) {
    this.billingSystem = billingSystem;
}
 
public void activateService(ServiceId serviceId, CustomerId customerId) {
    Service service = serviceRepository.findById(serviceId);
    
    if (service.requiresInitialPayment()) {
        billingSystem.chargeCustomer(
            customerId,
            service.getActivationFee(),
            new ChargeDescription("Service Activation: " + service.getName())
        );
    }
    
    service.activate();
    serviceRepository.save(service);
}
}

public class OrderSaga {
@Autowired
private CommandGateway commandGateway;
 
@StartSaga
@SagaEventHandler(associationProperty = "orderId")
public void handle(OrderPlacedEvent event) {
    String paymentId = UUID.randomUUID().toString();
    
    // Ассоциируем этот платеж с текущей сагой
    associateWith("paymentId", paymentId);
    
    // Отправляем команду в микросервис платежей
    commandGateway.send(new ProcessPaymentCommand(
        paymentId,
        event.getOrderId(),
        event.getAmount()
    ));
}
 
@SagaEventHandler(associationProperty = "paymentId")
public void handle(PaymentCompletedEvent event) {
    // Отправляем команду в микросервис инвентаря
    commandGateway.send(new ReserveInventoryCommand(
        event.getOrderId(),
        event.getOrderItems()
    ));
}
 
@SagaEventHandler(associationProperty = "orderId")
public void handle(InventoryReservedEvent event) {
    // Отправляем команду в микросервис доставки
    commandGateway.send(new ScheduleDeliveryCommand(
        event.getOrderId(),
        event.getShippingAddress()
    ));
}
 
@SagaEventHandler(associationProperty = "orderId")
public void handle(DeliveryScheduledEvent event) {
    commandGateway.send(new CompleteOrderCommand(event.getOrderId()));
    // Завершаем сагу
    end();
}
 
// Компенсирующие транзакции для отката
@SagaEventHandler(associationProperty = "paymentId")
public void handle(PaymentFailedEvent event) {
    // Отменяем заказ
    commandGateway.send(new CancelOrderCommand(event.getOrderId()));
    end();
}
 
@SagaEventHandler(associationProperty = "orderId")
public void handle(InventoryReservationFailedEvent event) {
    // Отменяем платеж
    commandGateway.send(new RefundPaymentCommand(
        event.getOrderId(),
        event.getPaymentId()
    ));
    
    // Отменяем заказ
    commandGateway.send(new CancelOrderCommand(event.getOrderId()));
    end();
}
}

// Слой 1: Доменные объекты
public class Shipment {
    private ShipmentId id;
    private Weight weight;
    // ...
}
 
// Слой 2: Спецификации
public class ValidShipmentSpecification implements Specification<Shipment> {
    // ...
}
 
// Слой 3: Доменные сервисы
public class ShipmentValidationService {
    private final ValidShipmentSpecification specification;
    // ...
}
 
// Слой 4: Прикладные сервисы
public class ShipmentApplicationService {
    private final ShipmentValidationService validationService;
    private final ShipmentRepository repository;
    // ...
}
 
// Слой 5: API
public class ShipmentController {
    private final ShipmentApplicationService service;
    // ...
}

// Анемичная модель
public class Order {
    private String id;
    private List<OrderItem> items;
    private BigDecimal total;
    private OrderStatus status;
    
    // Геттеры и сеттеры, никакой логики
}
 
public class OrderService {
    public void placeOrder(Order order) {
        validateOrder(order);
        calculateTotal(order);
        order.setStatus(OrderStatus.PLACED);
        orderRepository.save(order);
        notificationService.notifyCustomer(order);
    }
    
    private void validateOrder(Order order) {
        // Валидация, которая должна быть в Order
    }
    
    private void calculateTotal(Order order) {
        // Расчеты, которые должны быть в Order
    }
}

Order order = orderRepository.findById(orderId);
// Неявно загружает список items
for (OrderItem item : order.getItems()) {
    // Неявно загружает product для каждого item
    Product product = item.getProduct();
    // Неявно загружает category для каждого product
    Category category = product.getCategory();
    // ...
}

@Entity
public class Account {
    @Id
    private String id;
    
    @Version
    private Long version;
    
    // ... остальные поля и методы
    
    public void withdraw(Money amount) {
        // логика снятия средств
        DomainEvents.publish(new AccountChangedEvent(this.id));
    }
}
 
// В сервисе
public void handleWithdrawal(WithdrawCommand cmd) {
    try {
        Account account = accountRepository.findById(cmd.getAccountId());
        account.withdraw(cmd.getAmount());
        accountRepository.save(account);
    } catch (OptimisticLockingFailureException e) {
        // Обработка конфликта версий
    }
}
 
// Слушатель событий для инвалидации кэша
@EventListener
public void handleAccountChanged(AccountChangedEvent event) {
    cacheManager.evict("accounts", event.getAccountId());
}

@Service
public class PolicyFacade {
private final LegacyPolicySystem legacySystem;
private final NewPolicyDomainService newSystem;
private final FeatureToggleService featureToggles;
 
public PolicyResponse getPolicy(String policyNumber) {
    if (featureToggles.isEnabled("use-new-policy-service", policyNumber)) {
        try {
            return newSystem.getPolicy(policyNumber);
        } catch (Exception e) {
            // Логируем сбой и переходим на легаси-систему
            log.warn("Error in new policy service, falling back to legacy", e);
            return legacySystem.getPolicy(policyNumber);
        }
    }
    return legacySystem.getPolicy(policyNumber);
}
}

public class PolicyAntiCorruptionLayer {
public DomainPolicy toDomainModel(LegacyPolicy legacy) {
    return new DomainPolicy(
        new PolicyId(legacy.getPolicyNumber()),
        new Customer(
            new CustomerId(legacy.getClientId()),
            new PersonName(legacy.getClientFirstName(), legacy.getClientLastName())
        ),
        mapCoverages(legacy.getCoverageList()),
        mapVehicle(legacy.getVehicleData()),
        mapPolicyStatus(legacy.getStatus())
    );
}
 
public LegacyPolicy toLegacyModel(DomainPolicy domain) {
    LegacyPolicy legacy = new LegacyPolicy();
    legacy.setPolicyNumber(domain.getId().getValue());
    legacy.setClientId(domain.getCustomer().getId().getValue());
    // ... остальные преобразования
    return legacy;
}
 
private List<Coverage> mapCoverages(List<LegacyCoverage> legacyCoverages) {
    // Трансляция покрытий из легаси-формата в доменную модель
}
}