HttpServiceProxyFactory 微服务业务远程调用案例说明

HttpServiceProxyFactory 使用这个工厂类来创建 HTTP 服务的代理，并实现与外部服务的交互。 HttpServiceProxyFactory 类是一个用于创建 HTTP 服务代理的工厂类。它提供了一种机制，通过代理模式，允许开发者调用 HTTP 服务接口，就像调用本地方法一样，而实际的 HTTP 请求和响应处理则由代理对象负责。

业务场景：

1、假设你正在开发一个微服务应用，需要与多个外部 HTTP 服务进行通信。为了简化这些服务的调用，提高代码的复用性和可维护性，你可以使用 HttpServiceProxyFactory 来为每个外部服务创建一个代理。

2、假设你正在开发一个电子商务平台，需要与外部的支付服务和库存服务进行交互。这些服务提供了 HTTP API，你希望通过 HttpServiceProxyFactory 创建代理来简化这些服务的调用。

步骤 1: 定义外部服务的接口

首先，定义支付服务和库存服务的接口，使用 HttpExchange 注解标记需要通过 HTTP 调用的方法。

public interface PaymentService {
    @HttpExchange(method = "POST", url = "https://api.payment.com/process")
    Mono<PaymentResponse> processPayment(PaymentRequest request);
}

public interface InventoryService {
    @HttpExchange(method = "GET", url = "https://api.inventory.com/check")
    Flux<InventoryItem> checkInventory(String itemId);
}

步骤 2: 配置 HttpServiceProxyFactory

在 Spring 配置类中配置 HttpServiceProxyFactory，创建代理对象。

@Configuration
public class ServiceProxyConfig {

    @Bean
    public HttpServiceProxyFactory httpServiceProxyFactory() {
        return HttpServiceProxyFactory.builder(new MyHttpClientAdapter())
                                       .customArgumentResolver(new MyCustomArgumentResolver())
                                       .conversionService(myConversionService)
                                       .embeddedValueResolver(myStringValueResolver)
                                       .reactiveAdapterRegistry(myReactiveAdapterRegistry)
                                       .blockTimeout(Duration.ofSeconds(10))
                                       .build();
    }

    @Bean
    public PaymentService paymentService(HttpServiceProxyFactory httpServiceProxyFactory) {
        return httpServiceProxyFactory.createClient(PaymentService.class);
    }

    @Bean
    public InventoryService inventoryService(HttpServiceProxyFactory httpServiceProxyFactory) {
        return httpServiceProxyFactory.createClient(InventoryService.class);
    }
}

步骤 3: 使用服务代理

在业务逻辑中，注入并使用 PaymentService 和 InventoryService 的代理实例。

@Service
public class OrderService {

    private final PaymentService paymentService;
    private final InventoryService inventoryService;

    public OrderService(PaymentService paymentService, InventoryService inventoryService) {
        this.paymentService = paymentService;
        this.inventoryService = inventoryService;
    }

    public Mono<OrderResult> placeOrder(OrderDetails orderDetails) {
        // 检查库存
        return inventoryService.checkInventory(orderDetails.getItemId())
                                .collectList()
                                .flatMap(inventoryItems -> {
                                    if (inventoryItems.isEmpty()) {
                                        return Mono.error(new RuntimeException("Item out of stock"));
                                    }
                                    // 处理支付
                                    PaymentRequest paymentRequest = createPaymentRequest(orderDetails);
                                    return paymentService.processPayment(paymentRequest)
                                                 .map(paymentResponse -> new OrderResult(/* ... */));
                                });
    }

    private PaymentRequest createPaymentRequest(OrderDetails orderDetails) {
        // 创建支付请求
        return new PaymentRequest(/* ... */);
    }
}

步骤 4: 处理响应和异常

确保在业务逻辑中正确处理响应和可能的异常。

public class OrderResult {
    // 订单结果的数据
}

public class PaymentResponse {
    // 支付响应的数据
}

目的：

• 简化外部服务调用：通过 HttpServiceProxyFactory 创建的代理，简化了与外部服务的 HTTP 调用。
• 解耦业务逻辑：业务逻辑与 HTTP 请求的具体实现分离，提高了代码的可维护性。
• 提高代码复用性：定义的服务接口可以在多个地方重用，而无需重复编写 HTTP 请求代码。