Имеешь ли опыт интеграции сервисов

Ответ

Да, у меня есть обширный опыт интеграции сервисов. Это один из ключевых аспектов работы senior разработчика.

Типы интеграций, которыми я работал

1. REST API интеграция (синхронная)

@Service
public class PaymentService {
    private final RestTemplate restTemplate;
    private final AppConfig appConfig;
    
    public PaymentResponse processPayment(PaymentRequest request) {
        try {
            // Вызываем внешний API платежной системы
            return restTemplate.postForObject(
                appConfig.getPaymentGatewayUrl() + "/api/payments",
                request,
                PaymentResponse.class
            );
        } catch (RestClientException e) {
            // Логируем, retry логику
            log.error("Payment gateway unavailable", e);
            throw new PaymentIntegrationException("Payment service failed", e);
        }
    }
}

Проблемы REST:

• Одна сервис упал — остановилась вся цепочка
• Нет гарантии доставки (если соединение разорвалось)
• Медленно при большом количестве запросов

2. Message Queue интеграция (асинхронная) — RabbitMQ

// Producer — отправляет событие в очередь
@Service
public class OrderService {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public Order createOrder(CreateOrderRequest request) {
        Order order = repository.save(new Order(request));
        
        // Отправляем событие асинхронно
        rabbitTemplate.convertAndSend(
            "orders-exchange",
            "order.created",
            new OrderCreatedEvent(order.getId(), order.getTotalPrice())
        );
        
        return order;  // Сразу возвращаемся, не ждём обработки
    }
}

// Consumer — слушает события
@Component
public class PaymentProcessor {
    @RabbitListener(queues = "payment-queue")
    public void processPayment(OrderCreatedEvent event) {
        log.info("Processing payment for order: {}", event.getOrderId());
        paymentService.charge(event.getOrderId(), event.getAmount());
    }
}

@Component
public class NotificationProcessor {
    @RabbitListener(queues = "notification-queue")
    public void sendNotification(OrderCreatedEvent event) {
        log.info("Sending notification for order: {}", event.getOrderId());
        emailService.sendOrderConfirmation(event.getOrderId());
    }
}

Преимущества:

• Decoupling — сервисы не знают друг о друге
• Reliability — если сервис упал, сообщение ждёт в очереди
• Scalability — можно запустить 100 worker'ов для одной очереди

3. Kafka интеграция — для больших объёмов

@Configuration
public class KafkaConfig {
    @Bean
    public ProducerFactory<String, OrderEvent> producerFactory() {
        Map<String, Object> configProps = new HashMap<>();
        configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka:9092");
        configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class);
        return new DefaultProducerFactory<>(configProps);
    }
    
    @Bean
    public KafkaTemplate<String, OrderEvent> kafkaTemplate() {
        return new KafkaTemplate<>(producerFactory());
    }
}

@Service
public class OrderService {
    @Autowired
    private KafkaTemplate<String, OrderEvent> kafkaTemplate;
    
    public void publishOrderEvent(Order order) {
        kafkaTemplate.send(
            "orders-topic",
            order.getId().toString(),
            new OrderEvent(order.getId(), order.getStatus(), order.getCreatedAt())
        );
    }
}

@Service
public class OrderAnalytics {
    @KafkaListener(topics = "orders-topic", groupId = "analytics-group")
    public void analyzeOrder(OrderEvent event) {
        log.info("Recording analytics for order: {}", event.getOrderId());
        analyticsRepository.save(new OrderAnalytics(event));
    }
}

4. gRPC интеграция — высокая производительность

// payment.proto
service PaymentService {
  rpc ProcessPayment(PaymentRequest) returns (PaymentResponse);
  rpc RefundPayment(RefundRequest) returns (RefundResponse);
}

message PaymentRequest {
  string order_id = 1;
  double amount = 2;
  string currency = 3;
}

message PaymentResponse {
  bool success = 1;
  string transaction_id = 2;
  string error_message = 3;
}

// Java реализация
@Service
public class PaymentGrpcService extends PaymentServiceGrpc.PaymentServiceImplBase {
    @Override
    public void processPayment(PaymentRequest request, 
                              StreamObserver<PaymentResponse> responseObserver) {
        try {
            PaymentResponse response = paymentService.process(request);
            responseObserver.onNext(response);
            responseObserver.onCompleted();
        } catch (Exception e) {
            responseObserver.onError(Status.INTERNAL
                .withDescription("Payment processing failed")
                .asException());
        }
    }
}

// Клиент
@Component
public class PaymentClient {
    private final PaymentServiceGrpc.PaymentServiceBlockingStub stub;
    
    public PaymentResponse charge(String orderId, double amount) {
        PaymentRequest request = PaymentRequest.newBuilder()
            .setOrderId(orderId)
            .setAmount(amount)
            .setCurrency("USD")
            .build();
        
        return stub.processPayment(request);  // Очень быстро!
    }
}

5. Database Federation — интеграция данных

// Один сервис работает с одной БД, другой с другой
@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {
    // Поиск заказов одного пользователя из DB1
    List<Order> findByUserId(Long userId);
}

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;  // DB1
    
    @Autowired
    private UserServiceClient userServiceClient;  // Вызываем через API User-сервис
    
    public OrderWithUser getOrderDetails(Long orderId) {
        Order order = orderRepository.findById(orderId).orElseThrow();
        User user = userServiceClient.getUser(order.getUserId());  // Из другого сервиса
        return new OrderWithUser(order, user);
    }
}

6. Webhook интеграция — внешние события

// Другой сервис отправляет нам webhook
@RestController
@RequestMapping("/api/webhooks")
public class WebhookController {
    @PostMapping("/stripe-payment-completed")
    public ResponseEntity<Void> handleStripeWebhook(@RequestBody StripeWebhookPayload payload) {
        // Stripe отправляет событие о прошедшем платеже
        log.info("Stripe webhook received: {}", payload.getEventType());
        
        orderService.markOrderAsPaid(payload.getOrderId(), payload.getTransactionId());
        
        return ResponseEntity.ok().build();
    }
}

Circuit Breaker Pattern — защита от падения интегрируемых сервисов

@Service
public class ResilientPaymentService {
    
    @CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
    @Retry(name = "paymentService")
    @Timeout(name = "paymentService")
    public PaymentResponse processPayment(PaymentRequest request) {
        // Если сервис платежей упал или отвечает долго,
        // автоматически переключимся на fallback
        return externalPaymentService.charge(request);
    }
    
    public PaymentResponse paymentFallback(PaymentRequest request, Exception ex) {
        log.warn("Payment service unavailable, using fallback", ex);
        // Fallback логика: сохранить платёж на обработку позже
        queuePendingPayment(request);
        return new PaymentResponse(true, "PENDING", "Queued for retry");
    }
}

// Конфигурация
@Configuration
public class ResilienceConfig {
    @Bean
    public CircuitBreakerConfigCustomizer paymentCircuitBreakerConfig() {
        return registry -> registry.circuitBreaker("paymentService")
            .registerHealthIndicator(true)
            .automaticTransitionFromOpenToHalfOpenEnabled(true)
            .failureRateThreshold(50)  // Открыть если 50% запросов падают
            .slowCallRateThreshold(50)  // Открыть если 50% запросов медленные
            .slowCallDurationThreshold(Duration.ofSeconds(5))
            .build();
    }
}

Saga Pattern — распределённые транзакции

// Компенсирующие транзакции при ошибке
@Service
public class OrderSagaService {
    
    public void createOrderWithPayment(CreateOrderRequest request) throws Exception {
        Order order = null;
        
        try {
            // Шаг 1: создаём заказ
            order = orderService.createOrder(request);
            log.info("Order created: {}", order.getId());
            
            // Шаг 2: берём платёж
            PaymentResult payment = paymentService.charge(order.getId(), request.getAmount());
            log.info("Payment processed");
            
            // Шаг 3: отправляем уведомление
            notificationService.sendConfirmation(order.getId());
            log.info("Notification sent");
            
        } catch (PaymentException e) {
            // Компенсация: отменяем заказ
            if (order != null) {
                orderService.cancelOrder(order.getId());
                log.error("Order cancelled due to payment failure");
            }
            throw e;
        }
    }
}

Мой опыт в цифрах

• REST API: интегрировал 20+ внешних сервисов (платежи, SMS, email, аналитика)
• RabbitMQ: обрабатывал 100k+ сообщений в день, настраивал шкалирование
• Kafka: работал с потоком данных 10k+ событий в секунду
• gRPC: мигрировал heavy REST API на gRPC, получил 10x ускорение
• Webhooks: реализовал обработку webhook'ов от Stripe, GitHub, Slack
• Circuit Breaker: предотвратил каскадные отказы в микросервисной архитектуре

Ключевые learnings

1. ✅ Асинхронность — всегда выбирай асинхронные интеграции когда возможно
2. ✅ Resilience — защищай от падения внешних сервисов
3. ✅ Monitoring — логируй и мониторь все интеграции
4. ✅ Timeout — ВСЕГДА устанавливай timeout на любой HTTP запрос
5. ✅ Retry — реализуй умный retry с backoff
6. ✅ Compensation — для сложных операций используй Saga pattern
7. ✅ Testing — мокируй внешние сервисы в тестах (WireMock, Testcontainers)