Реализация Domain-Driven Design с Java

// Плохо: технический жаргон
public class UserDTO {
    private String usrName;
    private List<PurchItm> items;
}
 
// Хорошо: единый язык
public class Customer {
    private CustomerName name;
    private List<OrderItem> purchasedItems;
}

com.example.ecommerce
├── sales
│   └── domain
│       ├── Order.java (содержит цены, скидки, статусы оплаты)
│       └── ...
└── shipping
    └── domain
        ├── Order.java (содержит адреса, сроки, службу доставки)
        └── ...

public class Product {
    private final ProductId id;
    private String name;
    private Money price;
    
    // Сравнение только по идентификатору
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Product product = (Product) o;
        return id.equals(product.id);
    }
}

public final class Money {
    private final BigDecimal amount;
    private final Currency currency;
    
    // Конструктор, валидирующий входные параметры
    public Money(BigDecimal amount, Currency currency) {
        if (amount == null) throw new IllegalArgumentException("Amount cannot be null");
        if (currency == null) throw new IllegalArgumentException("Currency cannot be null");
        this.amount = amount;
        this.currency = currency;
    }
    
    // Бизнес-операции, возвращающие новые экземпляры
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new CurrencyMismatchException("Cannot add different currencies");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }
    
    // Здесь equals/hashCode сравнивают по всем полям
}

public class Order {  // Корень агрегата
    private final OrderId id;
    private CustomerId customerId;
    private List<OrderLine> orderLines;  // Часть агрегата
    private OrderStatus status;
    
    // Бизнес-метод, управляющий внутренними частями агрегата
    public void addProduct(Product product, int quantity) {
        if (status != OrderStatus.DRAFT) {
            throw new OrderAlreadyConfirmedException("Cannot modify confirmed order");
        }
        
        // Инкапсуляция изменений внутри агрегата
        OrderLine existingLine = findOrderLineByProduct(product);
        if (existingLine != null) {
            existingLine.increaseQuantity(quantity);
        } else {
            orderLines.add(new OrderLine(product, quantity));
        }
    }
}

public interface OrderRepository {
    Order findById(OrderId id);
    List<Order> findByCustomer(CustomerId customerId);
    void save(Order order);
    void remove(Order order);
}

public class OrderProcessingService {
    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;
    private final PaymentService paymentService;
    
    public void processOrder(OrderId orderId) {
        Order order = orderRepository.findById(orderId);
        
        // Проверка наличия товаров на складе
        boolean allAvailable = order.getOrderLines().stream()
                .allMatch(line -> inventoryService.isAvailable(line.getProductId(), line.getQuantity()));
        
        if (!allAvailable) {
            throw new ProductNotAvailableException("Some products are out of stock");
        }
        
        // Обработка платежа
        PaymentResult result = paymentService.processPayment(order);
        
        if (result.isSuccessful()) {
            order.confirm();
            orderRepository.save(order);
        } else {
            order.markPaymentFailed(result.getErrorMessage());
            orderRepository.save(order);
        }
    }
}

public class OrderFactory {
private final ProductCatalog productCatalog;
 
public Order createOrder(CustomerId customerId, Map<ProductId, Integer> items) {
    Order order = new Order(OrderId.generate(), customerId);
    
    for (Map.Entry<ProductId, Integer> entry : items.entrySet()) {
        Product product = productCatalog.getProduct(entry.getKey());
        if (product == null) {
            throw new ProductNotFoundException("Product not found: " + entry.getKey());
        }
        order.addProduct(product, entry.getValue());
    }
    
    return order;
}
}

public class OrderPlacedEvent {
private final OrderId orderId;
private final CustomerId customerId;
private final LocalDateTime timestamp;
private final List<OrderLineItem> items;
 
// Конструктор, геттеры...
}

@Service
public class OrderService {
private final OrderRepository repository;
private final ApplicationEventPublisher eventPublisher;
 
@Transactional
public void placeOrder(Order order) {
    repository.save(order);
    
    OrderPlacedEvent event = new OrderPlacedEvent(
        order.getId(),
        order.getCustomerId(),
        LocalDateTime.now(),
        order.getOrderLines()
    );
    
    eventPublisher.publishEvent(event);
}
}

public interface OrderSpecification {
boolean isSatisfiedBy(Order order);
}
 
public class HighValueOrderSpecification implements OrderSpecification {
private final Money threshold;
 
public HighValueOrderSpecification(Money threshold) {
    this.threshold = threshold;
}
 
@Override
public boolean isSatisfiedBy(Order order) {
    return order.getTotalAmount().isGreaterThanOrEqual(threshold);
}
}

public class AndSpecification implements OrderSpecification {
private final OrderSpecification left;
private final OrderSpecification right;
 
public AndSpecification(OrderSpecification left, OrderSpecification right) {
    this.left = left;
    this.right = right;
}
 
@Override
public boolean isSatisfiedBy(Order order) {
    return left.isSatisfiedBy(order) && right.isSatisfiedBy(order);
}
}

// Библиотека, используемая несколькими контекстами
package com.example.sharedkernel;
 
public final class Money {
    private final BigDecimal amount;
    private final Currency currency;
    
    // Методы, используемые во всех контекстах  
}

public class LegacySystemAdapter implements ModernServiceInterface {
    private final LegacySystem legacySystem;
    
    @Override
    public CustomerData getCustomerInfo(CustomerId id) {
        // Трансформация между моделями
        LegacyCustomerRecord record = legacySystem.findCustomerById(id.toString());
        return new CustomerData(
            new CustomerId(record.getId()),
            new CustomerName(record.getFirstName(), record.getLastName()),
            transformAddress(record.getAddressData())
        );
    }
}

public class PaymentReceivedEvent {
private final OrderId orderId;
private final PaymentId paymentId;
private final Money amount;
private final LocalDateTime occurredOn;
 
public PaymentReceivedEvent(OrderId orderId, PaymentId paymentId, Money amount) {
this.orderId = orderId;
this.paymentId = paymentId;
this.amount = amount;
this.occurredOn = LocalDateTime.now();
}
 
// Геттеры, но не сеттеры - события иммутабельны
}

@Service
public class OrderService {
private final OrderRepository orderRepository;
private final ApplicationEventPublisher eventPublisher;
 
@Transactional
public void confirmOrder(OrderId orderId) {
Order order = orderRepository.findById(orderId)
    .orElseThrow(() -> new OrderNotFoundException(orderId));
    
order.confirm();
orderRepository.save(order);
 
// Публикация события
eventPublisher.publishEvent(new OrderConfirmedEvent(orderId));
}
}
 
@Component
public class InventoryHandler {
@EventListener
public void handleOrderConfirmed(OrderConfirmedEvent event) {
// Резервирование товаров на складе
}
}

@Service
public class OrderProcessingSaga {
private final OrderService orderService;
private final PaymentService paymentService;
private final ShippingService shippingService;
 
@Transactional
public void process(OrderId orderId) {
try {
    // Шаг 1: Подтверждение заказа
    orderService.confirmOrder(orderId);
    
    // Шаг 2: Обработка платежа
    PaymentId paymentId = paymentService.processPayment(orderId);
    
    // Шаг 3: Организация доставки
    shippingService.arrangeShipment(orderId);
} catch (PaymentFailedException e) {
    // Компенсирующее действие при сбое платежа
    orderService.rejectOrder(orderId, "Payment failed: " + e.getMessage());
} catch (ShippingException e) {
    // Компенсация при проблеме с доставкой
    paymentService.refundPayment(orderId);
    orderService.rejectOrder(orderId, "Shipping failed: " + e.getMessage());
}
}
}

@Entity
public class Order {
@Id
private OrderId id;
 
@Version
private Long version;
 
// Другие поля
}

public class UserFactory {
    private final PasswordEncoder encoder;
    private final IdGenerator idGenerator;
    
    public User createUser(String email, String plainPassword, String firstName, String lastName) {
        if (!EmailValidator.isValid(email)) {
            throw new InvalidEmailException(email);
        }
        
        UserId id = idGenerator.nextId();
        String hashedPassword = encoder.encode(plainPassword);
        
        return new User(id, new Email(email), hashedPassword, 
                        new PersonName(firstName, lastName), UserStatus.ACTIVE);
    }
    
    public User reactivateDeactivatedUser(User deactivatedUser) {
        if (deactivatedUser.getStatus() != UserStatus.DEACTIVATED) {
            throw new IllegalUserStateException("Can only reactivate deactivated users");
        }
        
        // Клонирование пользователя с новым статусом
        return new User(deactivatedUser.getId(), 
                        deactivatedUser.getEmail(),
                        deactivatedUser.getPassword(),
                        deactivatedUser.getName(),
                        UserStatus.ACTIVE);
    }
}

com.example.ecommerce
├── catalog
│   ├── domain
│   │   ├── Product.java
│   │   ├── ProductRepository.java
│   │   └── ...
│   ├── application
│   │   ├── ProductSearchService.java
│   │   └── ...
│   └── infrastructure
│       ├── JpaProductRepository.java
│       └── ...
├── ordering
│   ├── domain
│   │   ├── Order.java
│   │   └── ...

public interface DiscountPolicy {
    Money calculateDiscount(Order order);
}
 
public class LoyaltyDiscountPolicy implements DiscountPolicy {
    @Override
    public Money calculateDiscount(Order order) {
        Customer customer = order.getCustomer();
        if (customer.getLoyaltyLevel() == LoyaltyLevel.GOLD) {
            return order.getTotalAmount().multiply(0.1); // 10% скидка для Gold-клиентов
        }
        return Money.ZERO;
    }
}

public interface Specification<T> {
    boolean isSatisfiedBy(T entity);
}
 
public class HighValueOrderSpecification implements Specification<Order> {
    private final Money threshold;
    
    // Конструктор, методы...
    
    @Override
    public boolean isSatisfiedBy(Order order) {
        return order.getTotalAmount().isGreaterThan(threshold);
    }
}

com.example.application
├── domain              // Ядро домена - наша сокровищница
│   ├── model           // Классы модели домена
│   │   ├── order
│   │   │   ├── Order.java
│   │   │   ├── OrderLine.java
│   │   │   └── OrderStatus.java
│   │   └── customer
│   │       └── ...
│   ├── service         // Сервисы предметной области
│   └── repository      // Интерфейсы репозиториев
├── application         // Прикладной уровень - оркестровка
│   ├── service         // Прикладные сервисы
│   ├── dto             // Объекты передачи данных
│   └── mapper          // Преобразователи между DTO и доменом
└── infrastructure      // Инфраструктурный уровень
    ├── persistence     // Реализация хранения данных
    │   ├── repository  // Конкретные реализации репозиториев
    │   └── entity      // Маппинг на сущности JPA (если используется)
    ├── security        // Безопасность
    └── integration     // Интеграция с внешними системами

public final class CustomerName {
private final String firstName;
private final String lastName;
 
public CustomerName(String firstName, String lastName) {
    // Валидация и защита инвариантов
    if (firstName == null || firstName.trim().isEmpty()) {
        throw new IllegalArgumentException("First name cannot be empty");
    }
    if (lastName == null || lastName.trim().isEmpty()) {
        throw new IllegalArgumentException("Last name cannot be empty");
    }
    
    this.firstName = firstName;
    this.lastName = lastName;
}
 
// Бизнес-методы
public String getFullName() {
    return firstName + " " + lastName;
}
 
// Equals и hashCode на основе всех полей
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    CustomerName that = (CustomerName) o;
    return firstName.equals(that.firstName) && 
           lastName.equals(that.lastName);
}
 
@Override
public int hashCode() {
    return Objects.hash(firstName, lastName);
}
}

public class Order {
private final OrderId id;  // Идентификатор - Value Object
private CustomerId customerId;
private final List<OrderLine> orderLines = new ArrayList<>();
private OrderStatus status = OrderStatus.DRAFT;
private DeliveryAddress deliveryAddress;
 
protected Order(OrderId id, CustomerId customerId) {
    this.id = id;
    this.customerId = customerId;
}
 
// Бизнес-метод, изменяющий состояние агрегата
public void addProduct(Product product, int quantity) {
    if (status != OrderStatus.DRAFT) {
        throw new OrderAlreadyConfirmedException(
            "Cannot modify order in status: " + status);
    }
    
    Optional<OrderLine> existingLine = findLineByProduct(product.getId());
    if (existingLine.isPresent()) {
        existingLine.get().increaseQuantity(quantity);
    } else {
        orderLines.add(new OrderLine(new OrderLineId(), product.getId(), 
            product.getPrice(), quantity));
    }
}
 
// Другие бизнес-методы
public void confirm() {
    if (orderLines.isEmpty()) {
        throw new EmptyOrderException("Cannot confirm an empty order");
    }
    
    if (deliveryAddress == null) {
        throw new MissingDeliveryAddressException("Delivery address is required");
    }
    
    this.status = OrderStatus.CONFIRMED;
}
 
// Геттеры, но не сеттеры для полей, изменяемых только через бизнес-методы
}

// Domain - доменная модель ничего не знает о JPA
public class Order {
    private final OrderId id;
    private CustomerId customerId;
    private List<OrderLine> orderLines;
    // ... бизнес-методы
}
 
// Infrastructure - JPA-сущность для хранения
@Entity
@Table(name = "orders")
public class OrderEntity {
    @EmbeddedId
    private OrderIdJpaEmbeddable id;
    
    @Column(name = "customer_id")
    private String customerId;
    
    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
    @JoinColumn(name = "order_id")
    private List<OrderLineEntity> orderLines;
    
    // ... геттеры и сеттеры
}
 
// Infrastructure - маппер между доменом и JPA
public class OrderMapper {
    public OrderEntity toEntity(Order order) {
        // Преобразование из доменной модели в JPA-сущность
    }
    
    public Order toDomain(OrderEntity entity) {
        // Преобразование из JPA-сущности в доменную модель
    }
}

public class JpaOrderRepository implements OrderRepository {
    private final OrderJpaRepository jpaRepository;
    private final OrderMapper mapper;
    
    @Override
    public Order findById(OrderId id) {
        return jpaRepository.findById(mapper.toJpaId(id))
            .map(mapper::toDomain)
            .orElseThrow(() -> new OrderNotFoundException(id));
    }
    
    @Override
    public void save(Order order) {
        OrderEntity entity = mapper.toEntity(order);
        jpaRepository.save(entity);
    }
}

// Порт в доменном слое
public interface PaymentGateway {
    PaymentResult processPayment(PaymentDetails details);
}
 
// Адаптер в инфраструктурном слое
@Service
public class StripePaymentAdapter implements PaymentGateway {
    private final StripeClient stripeClient;
    
    @Override
    public PaymentResult processPayment(PaymentDetails details) {
        // Адаптация доменного запроса к API Stripe
        StripePaymentRequest request = mapToStripeRequest(details);
        StripePaymentResponse response = stripeClient.charge(request);
        return mapToPaymentResult(response);
    }
}

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private final OrderApplicationService service;
    
    @PostMapping
    public OrderResponse createOrder(@RequestBody CreateOrderRequest request) {
        // Преобразование API-запроса в команду домена
        CreateOrderCommand command = mapToCommand(request);
        OrderId orderId = service.createOrder(command);
        
        // Возврат упрощённого ответа, а не доменной модели
        return new OrderResponse(orderId.getValue());
    }
}

public class OrderTest {
    @Test
    void shouldCreateOrderWithValidData() {
        // Arrange
        CustomerId customerId = new CustomerId("C12345");
        OrderId orderId = new OrderId("O98765");
        
        // Act
        Order order = new Order(orderId, customerId);
        
        // Assert
        assertEquals(customerId, order.getCustomerId());
        assertEquals(OrderStatus.DRAFT, order.getStatus());
    }
    
    @Test
    void shouldThrowExceptionWhenConfirmingEmptyOrder() {
        // Arrange
        Order order = createEmptyOrder();
        
        // Act & Assert
        assertThrows(EmptyOrderException.class, () -> order.confirm());
    }
    
    @Test
    void shouldChangeStatusToConfirmedWhenOrderIsValid() {
        // Arrange
        Order order = createValidOrder();
        
        // Act
        order.confirm();
        
        // Assert
        assertEquals(OrderStatus.CONFIRMED, order.getStatus());
    }
}

@Test
void shouldNotAllowConfirmationWithoutDeliveryAddress() {
    // Arrange
    Order order = OrderTestFactory.createOrderWithItems();
    // Намеренно не устанавливаем адрес доставки
    
    // Act & Assert
    MissingDeliveryAddressException exception = assertThrows(
        MissingDeliveryAddressException.class,
        () -> order.confirm()
    );
    
    assertThat(exception.getMessage()).contains("Delivery address is required");
}

@ParameterizedTest
@MethodSource("provideInvalidMoneyAmounts")
void shouldRejectInvalidMoneyAmounts(BigDecimal amount, Currency currency, String expectedErrorMessage) {
    // Act & Assert
    IllegalArgumentException exception = assertThrows(
        IllegalArgumentException.class,
        () -> new Money(amount, currency)
    );
    
    assertThat(exception.getMessage()).contains(expectedErrorMessage);
}
 
static Stream<Arguments> provideInvalidMoneyAmounts() {
    return Stream.of(
        Arguments.of(null, Currency.getInstance("USD"), "Amount cannot be null"),
        Arguments.of(BigDecimal.valueOf(-10), Currency.getInstance("USD"), "Amount cannot be negative"),
        Arguments.of(BigDecimal.valueOf(10), null, "Currency cannot be null")
    );
}

@Test
void shouldCalculateCorrectOrderTotal() {
    // Arrange
    Order order = createOrderWithMultipleItems();
    
    // Act
    Money total = order.calculateTotal();
    
    // Assert
    assertThat(total).isEqualToMoney("120.50", "USD");
    assertThat(order).hasStatus(OrderStatus.DRAFT)
                     .hasItemCount(3)
                     .isNotEligibleForFreeShipping();
}

// До Java 14
public final class ProductId {
    private final String value;
    
    public ProductId(String value) {
        this.value = Objects.requireNonNull(value, "Product ID cannot be null");
    }
    
    public String getValue() {
        return value;
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        ProductId productId = (ProductId) o;
        return value.equals(productId.value);
    }
    
    @Override
    public int hashCode() {
        return Objects.hash(value);
    }
}
 
// С Java 14+
public record ProductId(String value) {
    public ProductId {
        Objects.requireNonNull(value, "Product ID cannot be null");
    }
}

public record Money(BigDecimal amount, Currency currency) {
    public Money {
        if (amount == null) throw new IllegalArgumentException("Amount cannot be null");
        if (currency == null) throw new IllegalArgumentException("Currency cannot be null");
        if (amount.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Amount cannot be negative");
        }
    }
    
    public Money add(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new CurrencyMismatchException("Cannot add different currencies");
        }
        return new Money(this.amount.add(other.amount), this.currency);
    }
    
    public Money multiply(double multiplier) {
        return new Money(
            this.amount.multiply(BigDecimal.valueOf(multiplier))
                .setScale(2, RoundingMode.HALF_UP),
            this.currency
        );
    }
    
    public boolean isGreaterThan(Money other) {
        assertSameCurrency(other);
        return this.amount.compareTo(other.amount) > 0;
    }
    
    private void assertSameCurrency(Money other) {
        if (!this.currency.equals(other.currency)) {
            throw new CurrencyMismatchException("Cannot compare different currencies");
        }
    }
}

public Money calculateDiscount(DiscountStrategy strategy, Order order) {
    if (strategy instanceof PercentageDiscount percentDiscount) {
        return order.getTotalAmount().multiply(percentDiscount.getRate());
    } else if (strategy instanceof FixedAmountDiscount fixedDiscount) {
        return fixedDiscount.getAmount().min(order.getTotalAmount());
    } else {
        return Money.ZERO;
    }
}

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 HighValueOrderSpecification implements Specification<Order> {
    private final Money threshold;
    
    public HighValueOrderSpecification(Money threshold) {
        this.threshold = threshold;
    }
    
    @Override
    public boolean isSatisfiedBy(Order order) {
        return order.getTotalAmount().isGreaterThan(threshold);
    }
}
 
public class UrgentOrderSpecification implements Specification<Order> {
    @Override
    public boolean isSatisfiedBy(Order order) {
        return order.getDeliveryDate() != null && 
               order.getDeliveryDate().isBefore(LocalDate.now().plusDays(2));
    }
}

Specification<Order> priorityOrders = new HighValueOrderSpecification(new Money(BigDecimal.valueOf(1000), Currency.getInstance("USD")))
    .or(new UrgentOrderSpecification());
 
List<Order> importantOrders = orderRepository.findAllSatisfying(priorityOrders);

public class JpaOrderRepository implements OrderRepository {
    private final OrderJpaRepository jpaRepository;
    private final OrderSpecificationConverter specConverter;
    
    @Override
    public List<Order> findAllSatisfying(Specification<Order> spec) {
        // Конвертация доменной спецификации в JPA-спецификацию
        org.springframework.data.jpa.domain.Specification<OrderEntity> jpaSpec = 
            specConverter.toJpaSpecification(spec);
            
        return jpaRepository.findAll(jpaSpec)
            .stream()
            .map(this::toDomain)
            .collect(Collectors.toList());
    }
}

@Component
public class OrderSpecificationConverter {
public org.springframework.data.jpa.domain.Specification<OrderEntity> toJpaSpecification(
        Specification<Order> domainSpec) {
    
    if (domainSpec instanceof HighValueOrderSpecification highValueSpec) {
        Money threshold = highValueSpec.getThreshold();
        return (root, query, cb) -> cb.greaterThan(
            root.get("totalAmount"), threshold.amount().doubleValue());
    }
    
    if (domainSpec instanceof OrdersByDateRangeSpecification dateRangeSpec) {
        return (root, query, cb) -> cb.between(
            root.get("orderDate"), 
            dateRangeSpec.getStartDate(), 
            dateRangeSpec.getEndDate());
    }
    
    // Обработка композитных спецификаций
    if (domainSpec instanceof AndSpecification<Order> andSpec) {
        return toJpaSpecification(andSpec.getLeft())
            .and(toJpaSpecification(andSpec.getRight()));
    }
    
    throw new UnsupportedSpecificationException("Unsupported specification type");
}
}

@Override
public Page<Order> findAllSatisfying(Specification<Order> spec, Pageable pageable) {
    org.springframework.data.jpa.domain.Specification<OrderEntity> jpaSpec = 
        specConverter.toJpaSpecification(spec);
        
    return jpaRepository.findAll(jpaSpec, pageable)
        .map(mapper::toDomain);
}

@Component
public class OrderSpecificationFactory {
public Specification<Order> createFromCriteria(OrderSearchCriteria criteria) {
    Specification<Order> spec = Specification.all();
    
    if (criteria.getMinAmount() != null) {
        spec = spec.and(new HighValueOrderSpecification(criteria.getMinAmount()));
    }
    
    if (criteria.getDateFrom() != null && criteria.getDateTo() != null) {
        spec = spec.and(new OrdersByDateRangeSpecification(
            criteria.getDateFrom(), criteria.getDateTo()));
    }
    
    return spec;
}
}

// Domain layer
public interface OrderRepository {
    Order findById(OrderId id);
    List<Order> findByCustomerId(CustomerId customerId);
    List<Order> findAllSatisfying(Specification<Order> spec);
    void save(Order order);
}

// Infrastructure layer
@Repository
public interface OrderJpaRepository extends JpaRepository<OrderEntity, OrderIdJpaEmbeddable> {
    List<OrderEntity> findByCustomerId(String customerId);
}
 
@Service
public class SpringDataOrderRepository implements OrderRepository {
    private final OrderJpaRepository jpaRepository;
    private final OrderMapper mapper;
    
    @Override
    public Order findById(OrderId id) {
        return jpaRepository.findById(mapper.toJpaId(id))
            .map(mapper::toDomain)
            .orElseThrow(() -> new OrderNotFoundException(id));
    }
    
    @Override
    public List<Order> findByCustomerId(CustomerId customerId) {
        return jpaRepository.findByCustomerId(customerId.value())
            .stream()
            .map(mapper::toDomain)
            .collect(Collectors.toList());
    }
    
    // Другие методы...
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Entity {
String boundedContext() default "";
}
 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ValueObject {}
 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface AggregateRoot {
String boundedContext() default "";
}
 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface DomainService {}
 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DomainEvent {
String value() default "";
}

@AggregateRoot(boundedContext = "ordering")
public class Order {
    // ...
    
    @DomainEvent("order.confirmed")
    public void confirm() {
        // ...
    }
}
 
@ValueObject
public record Money(BigDecimal amount, Currency currency) {
    // ...
}
 
@Entity(boundedContext = "catalog")
public class Product {
    // ...
}

public class DddRulesValidator {
    public void validate(Class<?> clazz) {
        if (clazz.isAnnotationPresent(ValueObject.class)) {
            validateValueObject(clazz);
        }
        
        if (clazz.isAnnotationPresent(Entity.class) || 
            clazz.isAnnotationPresent(AggregateRoot.class)) {
            validateEntity(clazz);
        }
    }
    
    private void validateValueObject(Class<?> clazz) {
        // Проверка: все поля final? Есть equals/hashCode?
    }
    
    private void validateEntity(Class<?> clazz) {
        // Есть ли идентификатор? Правильно ли реализованы equals/hashCode?
    }
}

public interface BusinessRule<T> {
boolean evaluate(T target);
String getMessage();
}
 
public class OrderMustHaveItemsRule implements BusinessRule<Order> {
@Override
public boolean evaluate(Order order) {
    return !order.getItems().isEmpty();
}
 
@Override
public String getMessage() {
    return "Заказ должен содержать хотя бы один товар";
}
}
 
public class RuleEngine<T> {
private final List<BusinessRule<T>> rules = new ArrayList<>();
 
public RuleEngine<T> addRule(BusinessRule<T> rule) {
    rules.add(rule);
    return this;
}
 
public Optional<BusinessRule<T>> findFirstViolation(T target) {
    return rules.stream()
        .filter(rule -> !rule.evaluate(target))
        .findFirst();
}
 
public boolean validate(T target) {
    return findFirstViolation(target).isEmpty();
}
}

public class DiscountRuleBuilder {
private Predicate<Customer> customerCondition = c -> true;
private Predicate<Order> orderCondition = o -> true;
private Function<Order, Money> discountCalculator = o -> Money.ZERO;
 
public DiscountRuleBuilder forCustomersWho(Predicate<Customer> condition) {
    this.customerCondition = condition;
    return this;
}
 
public DiscountRuleBuilder forOrdersThat(Predicate<Order> condition) {
    this.orderCondition = condition;
    return this;
}
 
public DiscountRuleBuilder applyDiscount(Function<Order, Money> calculator) {
    this.discountCalculator = calculator;
    return this;
}
 
public DiscountRule build() {
    return new DiscountRule(customerCondition, orderCondition, discountCalculator);
}
}

DiscountRule loyalCustomerDiscount = new DiscountRuleBuilder()
    .forCustomersWho(c -> c.getLoyaltyLevel() == LoyaltyLevel.GOLD)
    .forOrdersThat(o -> o.getTotalAmount().isGreaterThan(Money.of(500, USD)))
    .applyDiscount(o -> o.getTotalAmount().multiply(0.1))
    .build();

public interface TaxCalculationStrategy {
Money calculateTax(Order order);
}
 
@Service
public class TaxRuleFactory {
private final Map<TaxRegime, TaxCalculationStrategy> strategies;
private final CustomerRepository customerRepository;
 
public TaxCalculationStrategy getStrategyFor(CustomerId customerId) {
    Customer customer = customerRepository.findById(customerId);
    return strategies.get(customer.getTaxRegime());
}
}

// Команда - используем богатую доменную модель
public class PlaceOrderCommand {
private final CustomerId customerId;
private final List<OrderItemDto> items;
private final DeliveryAddressDto address;
}
 
// Запрос - прямой доступ к оптимизированному представлению
public class OrderSummaryQuery {
private final CustomerId customerId;
}
 
// Результат запроса - плоская структура без доменной логики
public class OrderSummaryDto {
private String orderId;
private String customerName;
private String status;
private BigDecimal totalAmount;
private List<String> productNames;
}

com.example.shop
├── catalog
│   ├── domain
│   │   ├── model
│   │   │   ├── Product.java
│   │   │   ├── ProductId.java
│   │   │   └── ...
│   │   ├── repository
│   │   └── service
│   ├── application
│   └── infrastructure
├── sales
│   ├── domain
│   │   ├── model
│   │   │   ├── Order.java
│   │   │   ├── OrderLine.java
│   │   │   └── ...
│   │   ├── repository
│   │   └── service
│   ├── application
│   └── infrastructure
└── shipping
    ├── domain
    └── ...

// Идентификатор заказа - объект-значение
public record OrderId(UUID value) {
    public OrderId {
        Objects.requireNonNull(value, "Order ID value must not be null");
    }
 
    public static OrderId generateNew() {
        return new OrderId(UUID.randomUUID());
    }
}
 
// Агрегат Order - корень агрегата
public class Order {
    private final OrderId id;
    private CustomerId customerId;
    private final List<OrderLine> orderLines = new ArrayList<>();
    private OrderStatus status;
    private DeliveryAddress deliveryAddress;
    private Money totalAmount;
 
    protected Order(OrderId id, CustomerId customerId) {
        this.id = id;
        this.customerId = customerId;
        this.status = OrderStatus.DRAFT;
        this.totalAmount = Money.zero(Currency.USD);
    }
 
    // Бизнес-метод для добавления товара
    public void addProduct(ProductId productId, int quantity, Money unitPrice) {
        validateDraftStatus();
        
        // Поиск существующей позиции
        Optional<OrderLine> existingLine = findOrderLineByProductId(productId);
        
        if (existingLine.isPresent()) {
            existingLine.get().increaseQuantity(quantity);
        } else {
            orderLines.add(new OrderLine(OrderLineId.generateNew(), productId, quantity, unitPrice));
        }
        
        recalculateTotal();
    }
 
    // Метод подтверждения заказа
    public void confirm() {
        validateDraftStatus();
        
        if (orderLines.isEmpty()) {
            throw new EmptyOrderException("Cannot confirm an empty order");
        }
        
        if (deliveryAddress == null) {
            throw new MissingDeliveryAddressException("Delivery address is required");
        }
        
        status = OrderStatus.CONFIRMED;
    }
 
    private void validateDraftStatus() {
        if (status != OrderStatus.DRAFT) {
            throw new OrderModificationException(
                "Cannot modify order in " + status + " status");
        }
    }
 
    private void recalculateTotal() {
        totalAmount = orderLines.stream()
            .map(OrderLine::getLineTotal)
            .reduce(Money.zero(Currency.USD), Money::add);
    }
    
    // Геттеры и другие бизнес-методы...
}

// Интерфейс репозитория в домене
public interface OrderRepository {
    Optional<Order> findById(OrderId id);
    List<Order> findByCustomerId(CustomerId customerId);
    void save(Order order);
}
 
// Реализация с Spring Data JPA в инфраструктурном слое
@Repository
public class JpaOrderRepository implements OrderRepository {
    private final OrderJpaEntityRepository jpaRepository;
    private final OrderMapper mapper;
 
    @Override
    public Optional<Order> findById(OrderId id) {
        return jpaRepository.findById(mapper.toJpaId(id))
            .map(mapper::toDomain);
    }
    
    // Другие методы...
}

@Service
@Transactional
public class OrderApplicationService {
    private final OrderRepository orderRepository;
    private final ProductCatalogService productCatalog;
    private final PaymentService paymentService;
    private final ApplicationEventPublisher eventPublisher;
 
    // Конструктор для инъекции зависимостей...
 
    public OrderId createOrder(CreateOrderCommand command) {
        // Создание заказа через фабрику
        Order order = orderFactory.createOrder(command.getCustomerId());
        
        // Добавление товаров из комманды
        for (OrderItemDto item : command.getItems()) {
            // Получение актуальной цены из каталога
            ProductInfo product = productCatalog.getProductInfo(item.getProductId());
            order.addProduct(item.getProductId(), item.getQuantity(), product.getPrice());
        }
        
        // Установка адреса доставки
        order.setDeliveryAddress(command.getDeliveryAddress());
        
        // Сохранение и возврат ID
        orderRepository.save(order);
        
        // Публикация события
        eventPublisher.publishEvent(new OrderCreatedEvent(order.getId(), order.getCustomerId()));
        
        return order.getId();
    }
}

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    private final OrderApplicationService orderService;
    
    @PostMapping
    public ResponseEntity<OrderResponse> createOrder(@RequestBody CreateOrderRequest request) {
        // Преобразование API-модели в команду домена
        CreateOrderCommand command = requestMapper.toCommand(request);
        
        // Выполнение команды через сервис приложения
        OrderId orderId = orderService.createOrder(command);
        
        // Создание ответа для клиента
        OrderResponse response = new OrderResponse(orderId.value().toString());
        return ResponseEntity.ok(response);
    }
}

@Service
public class CatalogProductService implements ProductCatalogService {
    private final ProductApiClient productClient;
    
    @Override
    public ProductInfo getProductInfo(ProductId productId) {
        // Вызов внешнего API
        ProductDto productDto = productClient.getProduct(productId.value().toString());
        
        // Трансформация в модель, понятную контексту продаж
        return new ProductInfo(
            new ProductId(UUID.fromString(productDto.getId())),
            new Money(productDto.getPrice(), Currency.getInstance(productDto.getCurrency()))
        );
    }
}