Что после микросервисов - постмонолитная архитектура как новая реальность

/controllers
  /users
  /products
  /orders
/services
  /users
  /products
  /orders
/repositories
  /users
  /products
  /orders

/modules
  /users
    /controllers
    /services
    /repositories
  /products
    /controllers
    /services
    /repositories
  /orders
    /controllers
    /services
    /repositories

// До миграции - прямой вызов REST API
OrderDto order = restTemplate.getForObject("/orders/" + orderId, OrderDto.class);
 
// После абстрагирования
public interface OrderService {
    Order getOrder(String orderId);
}
 
// Реализация для микросервисов
public class RemoteOrderService implements OrderService {
    private final RestTemplate restTemplate;
    
    public Order getOrder(String orderId) {
        return restTemplate.getForObject("/orders/" + orderId, Order.class);
    }
}

// Локальная реализация после объединения сервисов
public class LocalOrderService implements OrderService {
    private final OrderRepository orderRepository;
    
    public Order getOrder(String orderId) {
        return orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException(orderId));
    }
}

public interface CustomerRepository {
    Customer findById(String customerId);
    void save(Customer customer);
}
 
// Реализация, читающая из нескольких источников
public class HybridCustomerRepository implements CustomerRepository {
    private final LegacyDbRepository legacyRepo;
    private final NewDbRepository newRepo;
    
    public Customer findById(String customerId) {
        // Сначала проверяем новую БД
        if (newRepo.exists(customerId)) {
            return newRepo.findById(customerId);
        }
        // Если не нашли, проверяем старую
        return legacyRepo.findById(customerId);
    }
    
    public void save(Customer customer) {
        // Записываем в обе БД
        legacyRepo.save(customer);
        newRepo.save(customer);
    }
}

/controllers
/services
/repositories
/utils

/modules
  /user-management
    /api
    /internal
    /domain
  /order-processing
    /api
    /internal
    /domain
  /payment-gateway
    /api
    /internal
    /domain
/shared
  /infrastructure
  /utils

/src
  /main
    /java
      /com
        /mycompany
          /app
            /module-a       # Модуль A
              /api          # Публичный API модуля
              /internal     # Внутренняя реализация
                /domain     # Доменная модель
                /service    # Бизнес-логика
                /repository # Доступ к данным
            /module-b       # Модуль B
              /api
              /internal
                /domain
                /service
                /repository
            /shared         # Общие компоненты
              /infrastructure
              /utils

// В module-a/api
public interface CustomerService {
    Customer getCustomer(String customerId);
    void updateCustomer(Customer customer);
}
 
// В module-b/internal/service
@Service
public class OrderProcessor {
    private final CustomerService customerService;
    
    public OrderProcessor(CustomerService customerService) {
        this.customerService = customerService;
    }
    
    public void processOrder(Order order) {
        Customer customer = customerService.getCustomer(order.getCustomerId());
        // Обработка заказа
    }
}

// Порт (первичный)
public interface OrderService {
    OrderId placeOrder(Cart cart, CustomerId customerId);
    Order getOrder(OrderId orderId);
}
 
// Бизнес-логика
@Service
public class OrderServiceImpl implements OrderService {
    private final OrderRepository orderRepository; // Вторичный порт
    private final PaymentGateway paymentGateway;   // Вторичный порт
    
    // Конструктор с DI
    
    @Override
    public OrderId placeOrder(Cart cart, CustomerId customerId) {
        // Бизнес-логика создания заказа
        Order order = Order.create(cart, customerId);
        orderRepository.save(order);
        paymentGateway.processPayment(order);
        return order.getId();
    }
    
    @Override
    public Order getOrder(OrderId orderId) {
        return orderRepository.findById(orderId)
            .orElseThrow(() -> new OrderNotFoundException(orderId));
    }
}
 
// Вторичный порт
public interface OrderRepository {
    void save(Order order);
    Optional<Order> findById(OrderId orderId);
}
 
// Адаптер для вторичного порта
@Repository
public class JpaOrderRepository implements OrderRepository {
    private final OrderJpaRepository jpaRepository;
    
    // Реализация с использованием JPA
}

// Конфигурация модуля A
@Configuration
@ComponentScan("com.mycompany.app.module-a.internal")
public class ModuleAConfiguration {
    @Bean
    public CustomerService customerService(
            CustomerRepository repository, 
            EventPublisher eventPublisher) {
        return new CustomerServiceImpl(repository, eventPublisher);
    }
}
 
// Конфигурация модуля B, использующего сервис из модуля A
@Configuration
@ComponentScan("com.mycompany.app.module-b.internal")
@Import(ModuleAConfiguration.class) // Импорт конфигурации модуля A
public class ModuleBConfiguration {
    @Bean
    public OrderProcessor orderProcessor(CustomerService customerService) {
        return new OrderProcessorImpl(customerService);
    }
}

@Test
public void moduleBShouldOnlyDependOnModuleAPublicApi() {
    JavaClasses classes = new ClassFileImporter()
        .importPackages("com.mycompany.app");
    
    ArchRule rule = classes()
        .that().resideInAPackage("com.mycompany.app.module-b..")
        .should().onlyDependOnClassesThat()
        .resideInAnyPackage(
            "com.mycompany.app.module-b..",
            "com.mycompany.app.module-a.api..",
            "com.mycompany.app.shared..",
            "java.."
        );
    
    rule.check(classes);
}

// В модуле A
module com.mycompany.app.module.a {
    exports com.mycompany.app.module.a.api;
    
    requires spring.context;
    requires com.mycompany.app.shared;
}
 
// В модуле B
module com.mycompany.app.module.b {
    exports com.mycompany.app.module.b.api;
    
    requires com.mycompany.app.module.a;
    requires spring.context;
    requires com.mycompany.app.shared;
}

// Доменная модель, отражающая бизнес-термины
public class Order {
    private OrderId id;
    private CustomerId customerId;
    private List<OrderLine> lines;
    private OrderStatus status;
    private DeliveryAddress deliveryAddress;
    private Money totalAmount;
    
    // Доменные методы
    public void addProduct(ProductId productId, Quantity quantity, Money unitPrice) {
        OrderLine line = new OrderLine(productId, quantity, unitPrice);
        lines.add(line);
        recalculateTotal();
    }
    
    public void confirm() {
        if (status != OrderStatus.DRAFT) {
            throw new InvalidOrderStateException(id, status, "confirm");
        }
        status = OrderStatus.CONFIRMED;
    }
    
    // Другие методы
}

@Entity
@Table(name = "orders")
public class Order {
    @Id
    private String id;
    
    private String customerId;
    private String status;
    
    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
    @JoinColumn(name = "order_id")
    private List<OrderLine> lines = new ArrayList<>();
    
    @Embedded
    private DeliveryAddress deliveryAddress;
    
    // ...
}
 
@Entity
@Table(name = "order_lines")
public class OrderLine {
    @Id
    private String id;
    
    private String productId;
    private int quantity;
    private BigDecimal unitPrice;
    
    // ...
}

// Событие — что-то произошло в прошлом
public interface DomainEvent {
    String getAggregateId();
    Instant getTimestamp();
}
 
public class OrderCreatedEvent implements DomainEvent {
    private final String orderId;
    private final String customerId;
    private final Instant timestamp;
    
    // Геттеры, конструктор
    
    @Override
    public String getAggregateId() {
        return orderId;
    }
    
    @Override
    public Instant getTimestamp() {
        return timestamp;
    }
}
 
// Другие события: OrderItemAddedEvent, OrderConfirmedEvent и т.д.
 
// Агрегат, поддерживающий Event Sourcing
public class OrderAggregate {
    private String id;
    private String customerId;
    private List<OrderItem> items = new ArrayList<>();
    private String status;
    
    private List<DomainEvent> uncommittedEvents = new ArrayList<>();
    
    // Конструктор для создания нового заказа
    public static OrderAggregate create(String orderId, String customerId) {
        OrderAggregate order = new OrderAggregate();
        order.applyNewEvent(new OrderCreatedEvent(orderId, customerId, Instant.now()));
        return order;
    }
    
    // Добавление товара в заказ
    public void addItem(String productId, int quantity, BigDecimal price) {
        applyNewEvent(new OrderItemAddedEvent(id, productId, quantity, price, Instant.now()));
    }
    
    // Применение нового события
    private void applyNewEvent(DomainEvent event) {
        uncommittedEvents.add(event);
        apply(event);
    }
    
    // Применение события к состоянию
    private void apply(DomainEvent event) {
        if (event instanceof OrderCreatedEvent) {
            apply((OrderCreatedEvent) event);
        } else if (event instanceof OrderItemAddedEvent) {
            apply((OrderItemAddedEvent) event);
        }
        // Другие типы событий
    }
    
    private void apply(OrderCreatedEvent event) {
        this.id = event.getAggregateId();
        this.customerId = event.getCustomerId();
        this.status = "DRAFT";
    }
    
    private void apply(OrderItemAddedEvent event) {
        OrderItem item = new OrderItem(
            event.getProductId(), 
            event.getQuantity(), 
            event.getPrice()
        );
        this.items.add(item);
    }
    
    // Получение и очистка несохраненных событий
    public List<DomainEvent> getUncommittedEvents() {
        return new ArrayList<>(uncommittedEvents);
    }
    
    public void clearUncommittedEvents() {
        uncommittedEvents.clear();
    }
    
    // Восстановление агрегата из истории событий
    public static OrderAggregate recreate(List<DomainEvent> events) {
        OrderAggregate order = new OrderAggregate();
        events.forEach(order::apply);
        return order;
    }
}

// Модель команд (для записи)
public class OrderCommandService {
    private final EventStore eventStore;
    private final EventBus eventBus;
    
    public void createOrder(CreateOrderCommand command) {
        // Проверка бизнес-правил
        OrderAggregate order = OrderAggregate.create(
            UUID.randomUUID().toString(), 
            command.getCustomerId()
        );
        
        // Сохранение событий
        List<DomainEvent> events = order.getUncommittedEvents();
        eventStore.save(events);
        order.clearUncommittedEvents();
        
        // Публикация событий для обновления представлений
        events.forEach(eventBus::publish);
    }
    
    // Другие команды
}
 
// Модель запросов (для чтения)
public class OrderQueryService {
    private final JdbcTemplate jdbcTemplate;
    
    public OrderDTO getOrder(String orderId) {
        return jdbcTemplate.queryForObject(
            "SELECT o.id, o.customer_id, o.status, o.created_at " +
            "FROM order_view o WHERE o.id = ?",
            new Object[]{orderId},
            (rs, rowNum) -> new OrderDTO(
                rs.getString("id"),
                rs.getString("customer_id"),
                rs.getString("status"),
                rs.getTimestamp("created_at").toInstant()
            )
        );
    }
    
    // Другие запросы
}