Service Communication

Master inter-service communication in Spring Boot microservices — RestTemplate, WebClient, OpenFeign, and patterns for resilient service-to-service HTTP calls.

// Enable Feign in main class or config
@EnableFeignClients
@SpringBootApplication
public class OrderServiceApplication { ... }

// Feign client — interface only, Spring generates implementation
@FeignClient(
    name = "payment-service",
    url = "${services.payment.url}",
    fallback = PaymentServiceFallback.class  // fallback on failure
)
public interface PaymentServiceClient {

    @PostMapping("/api/v1/payments")
    PaymentResponse processPayment(@RequestBody PaymentRequest request);

    @GetMapping("/api/v1/payments/{paymentId}")
    PaymentResponse getPayment(@PathVariable String paymentId);

    @DeleteMapping("/api/v1/payments/{paymentId}")
    void refundPayment(@PathVariable String paymentId);
}

// Fallback for circuit breaker
@Component
public class PaymentServiceFallback implements PaymentServiceClient {

    @Override
    public PaymentResponse processPayment(PaymentRequest request) {
        throw new ServiceUnavailableException("Payment service is unavailable");
    }

    @Override
    public PaymentResponse getPayment(String paymentId) {
        return PaymentResponse.unknown(paymentId);
    }

    @Override
    public void refundPayment(String paymentId) {
        // Log for retry queue
        log.error("Refund failed for payment {}, queued for retry", paymentId);
    }
}

// Usage in service:
@Service
public class OrderService {
    private final PaymentServiceClient paymentClient;

    @CircuitBreaker(name = "payment-service", fallbackMethod = "paymentFallback")
    @Retry(name = "payment-service")
    @TimeLimiter(name = "payment-service")
    public PaymentResponse chargeOrder(Order order) {
        return paymentClient.processPayment(PaymentRequest.from(order));
    }
}

The most dangerous microservices anti-pattern is synchronous call chains: Service A calls B calls C calls D. If D is slow, A is slow. Use async messaging (Kafka/RabbitMQ) for operations that don't need an immediate response. Reserve synchronous HTTP for queries that need real-time data. The Saga pattern handles distributed transactions across services without synchronous chains.