Антипаттерны микросервисной архитектуры

// Проблемный код в OrderService
public OrderResponse processOrder(OrderRequest request) {
    // Проверка наличия товара
    InventoryResponse inventoryResponse = inventoryClient.checkAvailability(request.getProductId());
    if (!inventoryResponse.isAvailable()) {
        throw new OutOfStockException();
    }
    
    // Проверка платежа
    PaymentResponse paymentResponse = paymentClient.processPayment(request.getPaymentDetails());
    if (!paymentResponse.isSuccessful()) {
        throw new PaymentFailedException();
    }
    
    // Оформление доставки
    ShippingResponse shippingResponse = shippingClient.arrangeShipping(request.getShippingAddress());
    if (!shippingResponse.isSuccessful()) {
        // Отмена платежа
        paymentClient.refundPayment(paymentResponse.getTransactionId());
        throw new ShippingFailedException();
    }
    
    // Создание заказа
    Order order = new Order(...);
    orderRepository.save(order);
    
    return new OrderResponse(order.getId());
}

Запрос пользователя
    ↓
OrderService → PaymentService → InvoiceService

// Пример нарушения SRP: PaymentService обрабатывает и пользователей,
// и платежи, и даже отвечает за отправку уведомлений
public class PaymentService {
    // Методы для управления пользователями
    public User registerUser(UserRegistrationRequest request) {
        // Логика регистрации пользователя
    }
    
    public void updateUserProfile(UserProfileUpdateRequest request) {
        // Логика обновления профиля
    }
    
    // Методы для обработки платежей
    public PaymentResponse processPayment(PaymentRequest request) {
        // Логика обработки платежа
    }
    
    public void refundPayment(RefundRequest request) {
        // Логика возврата платежа
    }
    
    // Методы для отправки уведомлений
    public void sendPaymentConfirmation(PaymentConfirmationRequest request) {
        // Логика отправки подтверждения платежа
    }
}

// Пример кода, уязвимого к проблемам несогласованности
@Service
public class InventoryService {
private final ProductRepository productRepository;
 
@Autowired
public InventoryService(ProductRepository productRepository) {
    this.productRepository = productRepository;
}
 
// Проблема: отсутствие контроля конкурентного доступа
public boolean reserveItem(String productId, int quantity) {
    Product product = productRepository.findById(productId)
      .orElseThrow(() -> new ProductNotFoundException(productId));
    
    // Проверка наличия нужного количества
    if (product.getAvailableQuantity() >= quantity) {
        // Обновляем доступное количество
        product.setAvailableQuantity(product.getAvailableQuantity() - quantity);
        productRepository.save(product);
        return true;
    }
    
    return false;
}
}

// Проблемная архитектура с общей базой данных
  +----------------+    +----------------+    +----------------+
  |   OrderService |    | PaymentService |    | ShippingService|
  +----------------+    +----------------+    +----------------+
           |                    |                     |
           |                    |                     |
           v                    v                     v
  +--------------------------------------------------------+
  |                   Shared Database                      |
  +--------------------------------------------------------+

// Пример Саги без компенсирующих транзакций
@Service
public class OrderProcessingService {
    private final OrderRepository orderRepository;
    private final PaymentClient paymentClient;
    private final InventoryClient inventoryClient;
    private final ShippingClient shippingClient;
    
    // Конструктор...
    
    // Проблема: нет компенсирующих действий при сбоях
    @Transactional
    public void processOrder(Order order) {
        // 1. Сохраняем заказ
        orderRepository.save(order);
        
        // 2. Резервируем товары
        inventoryClient.reserve(order.getItems());
        
        // 3. Обрабатываем платеж
        // Что если это падает после резервирования товаров?
        paymentClient.processPayment(order.getPayment());
        
        // 4. Планируем доставку
        // Что если это падает после успешного платежа?
        shippingClient.scheduleDelivery(order.getShippingDetails());
    }
}

// Пример: ProductService хранит информацию о продукте
@Entity
public class Product {
    @Id
    private String id;
    private String name;
    private String description;
    private BigDecimal price;
    private int stock;
    // ...
}
 
// В то же время OrderService хранит копию данных о продукте
@Entity
public class OrderItem {
    @Id
    private String id;
    private String productId;
    private String productName;  // Дублирование
    private BigDecimal productPrice;  // Дублирование
    private int quantity;
    // ...
}

// Антипаттерн: OrderService напрямую зависит от внутренней структуры данных PaymentService
@Service
public class OrderService {
    private final RestTemplate restTemplate;
    
    public Order createOrder(OrderRequest request) {
        // ... создание заказа ...
        
        // Проблема: прямая зависимость от внутренней структуры PaymentService
        PaymentProcessingRequest paymentRequest = new PaymentProcessingRequest();
        paymentRequest.setPaymentMethodId(request.getPaymentDetails().getMethodId());
        paymentRequest.setCardNumber(request.getPaymentDetails().getCardNumber());
        paymentRequest.setCvv(request.getPaymentDetails().getCvv());
        paymentRequest.setTransactionType("AUTH_CAPTURE"); // Внутренний код PaymentService
        paymentRequest.setAccountingCode("450-A"); // Внутренний код PaymentService
        
        // Если PaymentService изменит эти внутренние коды, OrderService сломается
        PaymentResponse response = restTemplate.postForObject("/payments", paymentRequest, PaymentResponse.class);
        
        // ... обработка ответа ...
    }
}

Версия 1 Сервиса A → Обновление схемы данных → Версия 2 Сервиса A
                                                       ↓
                                    Сервис B (зависит от версии 1) → Сбой

// Пример эволюционной совместимости API
@Deprecated // Помечаем устаревшую версию, но сохраняем её работоспособность
@GetMapping("/api/v1/customers/{id}")
public CustomerV1 getCustomerV1(@PathVariable Long id) {
    Customer customer = customerRepository.findById(id).orElseThrow();
    return convertToV1(customer);
}
 
@GetMapping("/api/v2/customers/{id}")
public CustomerV2 getCustomerV2(@PathVariable Long id) {
    Customer customer = customerRepository.findById(id).orElseThrow();
    return convertToV2(customer);
}
 
// Внутренние преобразования обеспечивают совместимость
private CustomerV1 convertToV1(Customer customer) {
    // ... преобразование в старый формат ...
}
 
private CustomerV2 convertToV2(Customer customer) {
    // ... преобразование в новый формат с дополнительными полями ...
}

// Пример: Добавление трассировки запросов с помощью Spring Cloud Sleuth
@RestController
public class OrderController {
    private final Logger log = LoggerFactory.getLogger(OrderController.class);
    private final OrderService orderService;
    
    @Autowired
    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }
    
    @GetMapping("/orders/{id}")
    public ResponseEntity<Order> getOrder(@PathVariable String id) {
        log.info("Received request to find order with id: {}", id);
        // Spring Cloud Sleuth автоматически добавит trace и span IDs 
        // для отслеживания запроса через все микросервисы
        Order order = orderService.findById(id);
        log.info("Returning order: {}", order);
        return ResponseEntity.ok(order);
    }
}

// Пример: отсутствие Circuit Breaker приводит к каскадным отказам
@Service
public class ProductService {
    
    private final RestTemplate restTemplate;
    
    // Проблемный код: нет защиты от сбоев
    public ProductDetails getProductDetails(String productId) {
        // Прямой вызов зависимого сервиса без защиты от сбоев
        // Если inventory-service недоступен или отвечает медленно, 
        // это может привести к исчерпанию ресурсов и каскадному сбою
        InventoryStatus inventory = restTemplate.getForObject(
            "http://inventory-service/inventory/" + productId, 
            InventoryStatus.class);
            
        // ... остальная логика ...
    }
}

// Пример небезопасного кода для взаимодействия между сервисами
@Service
public class InsecureOrderService {
    
  @Value("${payment.service.apikey}")
  private String apiKey; // Общий секрет, жестко закодированный в конфигурации
    
  public OrderStatus processOrder(Order order) {
      // Небезопасный HTTP вызов без TLS
      String url = "http://payment-service/api/process";
        
      // Отправка API ключа в открытом виде в заголовке
      HttpHeaders headers = new HttpHeaders();
      headers.set("API-Key", apiKey);
        
      HttpEntity<Order> entity = new HttpEntity<>(order, headers);
      ResponseEntity<PaymentResult> response = restTemplate.exchange(
          url, HttpMethod.POST, entity, PaymentResult.class);
            
      // ... дальнейшая обработка ...
  }
}

// Пример "распределенного монолога"
@Service
public class OrderProcessor {
    
  private final KafkaTemplate<String, OrderEvent> kafkaTemplate;
    
  // Проблема: после отправки события нет обратной связи о результатах
  public void processOrder(Order order) {
      // Создаем событие и отправляем его
      OrderEvent event = new OrderEvent("ORDER_CREATED", order);
      kafkaTemplate.send("orders-topic", event);
        
      // Сервис не знает, было ли событие успешно обработано другими сервисами
      // Нет механизма получения статуса или уведомления о проблемах
  }
}

// До рефакторинга: синхронный вызов
public OrderConfirmation createOrder(OrderRequest request) {
    // Синхронный вызов сервиса инвентаря
    InventoryResponse inventoryResponse = inventoryClient.checkInventory(request.getItems());
    if (!inventoryResponse.isAvailable()) {
        throw new OutOfStockException();
    }
    // Остальная логика...
}
 
// После рефакторинга: асинхронное взаимодействие
public OrderAcceptance createOrder(OrderRequest request) {
    // Создаем заказ в состоянии "ожидание проверки"
    Order order = new Order(request, OrderStatus.PENDING_INVENTORY_CHECK);
    orderRepository.save(order);
    
    // Публикуем событие для асинхронной проверки
    eventPublisher.publish(new OrderCreatedEvent(order.getId(), request.getItems()));
    
    // Возвращаем подтверждение принятия заказа
    return new OrderAcceptance(order.getId(), "Заказ принят и обрабатывается");
}
 
// В другом сервисе или компоненте:
@EventListener
public void onOrderCreated(OrderCreatedEvent event) {
    boolean available = inventoryService.checkAvailability(event.getItems());
    if (available) {
        eventPublisher.publish(new InventoryConfirmedEvent(event.getOrderId()));
    } else {
        eventPublisher.publish(new InventoryRejectedEvent(event.getOrderId()));
    }
}