采用函数式编程实现通用化 Feign 分页 API 调用与参数绑定

本文探讨如何通过函数式编程方法，优雅地通用化处理具有不同参数数量的 feign 分页 api 调用。通过引入参数绑定机制和统一的 `pagingapi` 接口，我们能够避免为每个 api 定义大量重复的适配器类，实现更简洁、描述性强的代码，有效抽取分页逻辑，提高代码复用性和可维护性。

在现代微服务架构中，Feign 作为声明式 HTTP 客户端被广泛应用于服务间的调用。然而，当需要处理大量具有分页功能且参数结构各异的 Feign API 时，如何设计一套通用且灵活的调用机制，以避免重复代码和繁琐的适配器定义，是一个常见的挑战。本文将深入探讨如何利用 Java 8+ 的函数式编程特性，构建一个高度抽象和可复用的 Feign 分页 API 调用框架。

原始实现及其局限性

最初的实现尝试通过定义特定的接口和包装类来适配不同参数数量的 Feign API。例如，对于只有一个额外参数的分页 API，可能需要定义 SingleParamPagingApi 接口和 SingleParamPageableCall 类。

以下是原始实现的关键代码结构：

// 辅助类定义
@Builder
public static class BaseFeignResult {
    private final ResponseEntity> resp;
    private final RuntimeException excp;
}

// 针对单参数分页API的接口
public interface SingleParamPagingApi {
    ResponseEntity> callFeignApi(String arg, int page, int size) throws RuntimeException;
}

// 统一的分页调用接口
public interface PagedCall {
    BaseFeignResult call(int p, int s);
}

// 单参数分页API的适配器实现
public static class SingleParamPageableCall implements PagedCall {
    SingleParamPagingApi fun;
    String param;

    public SingleParamPageableCall(SingleParamPagingApi fun, String param) {
        this.fun = fun;
        this.param = param;
    }

    @Override
    public BaseFeignResult call(int p, int s) {
        BaseFeignResult.BaseFeignResultBuilder builder = BaseFeignResult.builder();
        try {
            builder.resp(fun.callFeignApi(param, p, s));
        } catch (RuntimeException e) {
            builder.excp(e);
        }
        return builder.build();
    }
}

// 分页数据抽取逻辑（递归实现）
public class FeignDrainer {
    public  List> drainFeignPageableCall(PagedCall feignCall) {
        BaseFeignResult firstPage = feignCall.call(0, 10);
        List> baseFeignResults = new ArrayList<>();
        baseFeignResults.add(firstPage);
        return drainFeignPageableCall(feignCall, firstPage, baseFeignResults, 1);
    }

    private  List> drainFeignPageableCall(
            PagedCall feignCall,
            BaseFeignResult dataPage,
            List> acc,
            int page
    ) {
        // 假设每页大小为10，通过余数判断是否为最后一页
        if (dataPage.resp != null && dataPage.resp.getBody().getData().size() % 10 > 0) {
            return acc;
        }
        if (dataPage.resp != null && dataPage.resp.getBody().getData().isEmpty()) { // 考虑最后一页数据为空的情况
            return acc;
        }

        BaseFeignResult res = feignCall.call(page, 10);
        acc.add(res);

        // 递归调用
        return drainFeignPageableCall(feignCall, res, acc, ++page);
    }
}

这种方法的局限性在于，每当遇到一个参数数量不同的 Feign API 时（例如，零个额外参数、两个额外参数等），都需要重新定义对应的 XParamPagingApi 接口和 XParamPageableCall 类，导致大量的样板代码和较低的代码复用性。这与“描述性地实现参数映射”的目标相去甚远。

函数式编程的解决方案

为了解决上述问题，我们可以引入函数式编程的思想，利用 Java 8 的 lambda 表达式和函数式接口来动态绑定 Feign API 的前置参数，从而实现一个高度通用的分页 API 调用机制。

核心思路是：

1. 定义一系列针对不同参数数量的函数式接口，用于描述 Feign API 的原始签名。
2. 创建一个统一的 PagingApi 接口，它只接收 page 和 size 参数。
3. 在 PagingApi 接口中提供静态工厂方法（of 方法），通过 lambda 表达式将具体 Feign API 的前置参数进行绑定，返回一个统一的 PagingApi 实例。

1. 定义多参数函数式接口

首先，我们定义针对不同数量前置参数的函数式接口。这些接口将用于匹配 Feign 客户端中实际的 API 方法签名。

// 辅助类：假设IVDPagedResponseOf是包含分页信息的响应体
public class IVDPagedResponseOf {
    private List data;
    // ... 其他分页信息，如总页数，总记录数等
    public List getData() { return data; }
    public void setData(List data) { this.data = data; }
}

// 针对一个额外参数的Paging API接口
@FunctionalInterface
public interface PagingApi1 {
    ResponseEntity> callFeignApi(A0 arg0, int page, int size) throws RuntimeException;
}

// 针对两个额外参数的Paging API接口
@FunctionalInterface
public interface PagingApi2 {
    ResponseEntity> callFeignApi(A0 arg0, A1 arg1, int page, int size) throws RuntimeException;
}

// 可以根据需要定义更多参数数量的接口，如 PagingApi0, PagingApi3 等

2. 统一分页接口与参数绑定

接下来，我们定义一个统一的 PagingApi 接口，它只关心 page 和 size 参数。最重要的是，我们通过静态 of 方法，将多参数的 PagingApiX 实例与具体参数绑定，转换为这个统一的 PagingApi 实例。

@FunctionalInterface
public interface PagingApi {
    ResponseEntity> callFeignApi(int page, int size) throws RuntimeException;

    // 静态工厂方法：绑定一个额外参数
    static  PagingApi of(PagingApi1 api, A0 arg0) {
        return (p, s) -> api.callFeignApi(arg0, p, s);
    }

    // 静态工厂方法：绑定两个额外参数
    static  PagingApi of(PagingApi2 api, A0 arg0, A1 arg1) {
        return (p, s) -> api.callFeignApi(arg0, arg1, p, s);
    }
    // 可以继续添加更多参数数量的of方法
}

通过 PagingApi.of 方法，我们可以在运行时将 Feign 客户端的具体方法引用（例如 ordersFeignClient::getOrdersBySampleIds）与它的前置参数（例如 "34596"）绑定起来，生成一个只接受 page 和 size 的 PagingApi 实例。

3. 适配通用分页调用

有了统一的 PagingApi 接口，我们现在可以创建一个通用的 PageableCall 类，它不再需要关心原始 Feign API 有多少个前置参数，只需要接收一个 PagingApi 实例即可。

// 统一的BaseFeignResult定义
@Builder
public static class BaseFeignResult {
    private final ResponseEntity> resp;
    private final RuntimeException excp;
    // Getter methods
    public ResponseEntity> getResp() { return resp; }
    public RuntimeException getExcp() { return excp; }
}

// 通用的PageableCall适配器
public static class PageableCall implements PagedCall {
    PagingApi fun;

    public PageableCall(PagingApi fun) {
        this.fun = fun;
    }

    @Override
    public BaseFeignResult call(int p, int s) {
        BaseFeignResult.BaseFeignResultBuilder builder = BaseFeignResult.builder();
        try {
            builder.resp(fun.callFeignApi(p, s));
        } catch (RuntimeException e) {
            builder.excp(e);
        }
        return builder.build();
    }
}

4. 重构分页数据抽取逻辑（迭代实现）

原始的分页数据抽取逻辑使用了递归，这在处理大量分页数据时可能导致栈溢出，并且可读性不如迭代。建议将其重构为迭代实现。

public class FeignDrainer {
    private final int pageSize;

    public FeignDrainer(int pageSize) {
        this.pageSize = pageSize;
    }

    /**
     * 抽取所有分页数据，采用迭代方式
     * @param feignCall 统一的分页调用接口
     * @param  数据类型
     * @return 所有页的数据列表
     */
    public  List> drainAllPages(PagedCall feignCall) {
        List> allResults = new ArrayList<>();
        int page = 0;
        boolean hasMoreData = true;

        while (hasMoreData) {
            BaseFeignResult currentPageResult = feignCall.call(page, pageSize);
            allResults.add(currentPageResult);

            if (currentPageResult.getResp() == null || currentPageResult.getExcp() != null) {
                // 如果请求失败或无响应体，停止抽取
                hasMoreData = false;
            } else {
                List data = currentPageResult.getResp().getBody().getData();
                // 判断是否为最后一页：如果返回的数据量小于请求的页面大小，则说明是最后一页
                // 或者数据为空，也视为最后一页
                if (data == null || data.size() < pageSize) {
                    hasMoreData = false;
                } else {
                    page++;
                }
            }
        }
        return allResults;
    }
}

完整示例与调用方式

假设我们有一个 Feign 客户端 ordersFeignClient，其中包含一个方法 getOrdersBySampleIds：

// 假设这是你的Feign客户端接口
public interface OrdersFeignClient {
    ResponseEntity> getOrdersBySampleIds(String sampleId, int page, int size);
    // 假设还有其他分页API，例如：
    // ResponseEntity> getProductsByCategory(String category, String brand, int page, int size);
}

// 假设GetOrderInfoDto是订单信息的数据结构
public class GetOrderInfoDto {
    private String orderId;
    // ...
}

现在，我们可以这样调用通用的分页抽取逻辑：

// 实例化 Feign 客户端 (此处为简化，实际应通过Spring等注入)
OrdersFeignClient ordersFeignClient = new OrdersFeignClient() {
    @Override
    public ResponseEntity> getOrdersBySampleIds(String sampleId, int page, int size) {
        // 模拟API调用结果
        List data = new ArrayList<>();
        if (page == 0) {
            data.add(new GetOrderInfoDto() {{ setOrderId("order-1"); }});
            data.add(new GetOrderInfoDto() {{ setOrderId("order-2"); }});
        } else if (page == 1) {
            data.add(new GetOrderInfoDto() {{ setOrderId("order-3"); }});
        }
        IVDPagedResponseOf responseOf = new IVDPagedResponseOf<>();
        responseOf.setData(data);
        return ResponseEntity.ok(responseOf);
    }
};

// 实例化分页抽取器，指定每页大小
FeignDrainer feignDrainer = new FeignDrainer(2); // 假设每页大小为2

// 调用方式：
List> allOrders = feignDrainer.drainAllPages(
        new PageableCall<>(
                PagingApi.of(ordersFeignClient::getOrdersBySampleIds, "34596")
        )
);

System.out.println("Fetched " + allOrders.size() + " pages of orders.");
allOrders.forEach(result -> {
    if (result.getResp() != null && result.getResp().getBody() != null) {
        result.getResp().getBody().getData().forEach(order -> System.out.println("Order ID: " + order.getOrderId()));
    }
});

// 如果有另一个API，例如 getProductsByCategory(String category, String brand, int page, int size)
// 假设 ProductInfo 类存
在
// List> allProducts = feignDrainer.drainAllPages(
//         new PageableCall<>(
//                 PagingApi.of(ordersFeignClient::getProductsByCategory, "Electronics", "Sony")
//         )
// );

通过这种方式，我们只需在 PagingApi 中定义不同参数数量的 of 方法，即可适配各种 Feign API。调用时，我们使用方法引用 ordersFeignClient::getOrdersBySampleIds 和具体的参数值，通过 PagingApi.of 进行绑定，生成一个统一的 PagingApi 实例，再传递给 PageableCall 和 FeignDrainer。

优势与注意事项

优势

1. 减少样板代码： 避免为每个不同参数数量的 Feign API 创建专属的接口和适配器类。
2. 提高可读性： 通过 PagingApi.of 方法，参数绑定过程更加直观和描述性。
3. 增强灵活性： 轻松支持任意数量前置参数的 Feign API，只需扩展 PagingApiX 接口和 PagingApi.of 方法即可。
4. 符合函数式编程范式： 利用 lambda 表达式和方法引用，使代码更简洁、更具表达力。

注意事项

1. 接口合并： 进一步简化，PagingApi 和 PagedCall 实际上可以合并成一个接口，直接在 PagingApi 中实现 call 方法的异常处理逻辑。例如：

   @FunctionalInterface
   public interface UnifiedPagedApi {
       BaseFeignResult call(int p, int s);
   
       static  UnifiedPagedApi of(PagingApi1 api, A0 arg0) {
           return (p, s) -> {
               BaseFeignResult.BaseFeignResultBuilder builder = BaseFeignResult.builder();
               try {
                   builder.resp(api.callFeignApi(arg0, p, s));
               } catch (RuntimeException e) {
                   builder.excp(e);
               }
               return builder.build();
           };
       }
       // ... 其他of方法
   }
   // 然后 FeignDrainer 直接使用 UnifiedPagedApi
   // public  List> drainAllPages(UnifiedPagedApi feignCall) { ... }

2. 分页逻辑的健壮性： drainAllPages 方法中判断分页结束的逻辑需要根据实际 API 的响应进行调整。例如，有些 API 会返回总页数或总记录数，这比仅仅判断当前页数据量是否小于 pageSize 更准确。

3. 异常处理： BaseFeignResult 的设计有效地封装了正常响应和运行时异常，这对于统一处理 API 调用结果非常有用。

4. 泛型与类型安全： 在使用 PagingApiX 和 PagingApi 时，要确保泛型参数 T 的正确传递，以维持类型安全。

总结

通过引入函数式编程的参数绑定机制，我们成功地将 Feign 分页 API 的通用化调用提升到了一个新的水平。这种方法不仅显著减少了样板代码，提高了代码的复用性和可维护性，还使得 API 调用逻辑更加清晰和描述性。在处理大量具有不同参数签名的分页 API 场景中，这种模式提供了一个优雅而强大的解决方案。