Java泛型类中无需强制类型转换访问具体类方法的实现方案

我有一个用于向Kafka发布事件列表的方法：

public class EventProducerService<T>{
private Future<Void> publish(List<T> events) {
        final String topicPublishURL = Url + String.format(PUBLISH_EVENT_URI_TEMPLATE, this.topic);

        final String body;
        try {
            body = JacksonUtils.toJson(events);
        } catch (JsonProcessingException e) {
            return Future.failedFuture(e);
        }

        return httpRequester.postAsync(httpClientWrapper.getOrCreateClient(), topicPublishURL, body);
    }
}

该类通过以下方式实例化：

new EventProducerService(httpClientWrapper, tokensFacade, WRITE_URL,
            topic, BUFFER_SIZE, vertx, metricRegistry);

我希望在发布成功后将事件信息发送至追踪服务。List<T>中的T可以是不同类，各自拥有独特方法，我需要追踪其中的OrderTrackingInfoEvent类。
请问如何在上述publish方法中访问OrderTrackingInfoEvent的方法？请注意不能使用强制类型转换。
我是Java新手，恳请帮助。

有人建议我在EventProducerService上指定一个发布处理器，在httpRequester.postAsync(...)执行完成后调用，传入返回的Future和事件列表，且该处理器需在构造EventProducerService实例时指定。

1. 定义发布处理器接口 #

先定义一个函数式接口，用于封装发布成功后的处理逻辑：

@FunctionalInterface
public interface PublishCompletionHandler<T> {
    void onSuccess(List<T> events);
    // 可选：如需处理失败场景，可添加下面的方法
    // void onFailure(Throwable error, List<T> events);
}

2. 修改EventProducerService的构造与发布逻辑 #

给EventProducerService增加处理器成员变量，并在构造时传入；同时修改publish方法，在请求成功后触发处理器：

public class EventProducerService<T>{
    private final PublishCompletionHandler<T> completionHandler;
    // 原有成员变量保留：httpClientWrapper、tokensFacade、Url、topic等

    // 更新构造函数，加入处理器参数
    public EventProducerService(HttpClientWrapper httpClientWrapper, TokensFacade tokensFacade, String WRITE_URL,
                                String topic, int BUFFER_SIZE, Vertx vertx, MetricRegistry metricRegistry,
                                PublishCompletionHandler<T> completionHandler) {
        // 初始化原有成员变量
        this.httpClientWrapper = httpClientWrapper;
        this.tokensFacade = tokensFacade;
        this.Url = WRITE_URL;
        this.topic = topic;
        // ... 其他成员变量的初始化代码
        this.completionHandler = completionHandler;
    }

    // 修改publish方法，添加成功回调
    private Future<Void> publish(List<T> events) {
        final String topicPublishURL = Url + String.format(PUBLISH_EVENT_URI_TEMPLATE, this.topic);

        final String body;
        try {
            body = JacksonUtils.toJson(events);
        } catch (JsonProcessingException e) {
            return Future.failedFuture(e);
        }

        return httpRequester.postAsync(httpClientWrapper.getOrCreateClient(), topicPublishURL, body)
                .onSuccess(v -> {
                    if (completionHandler != null) {
                        completionHandler.onSuccess(events);
                    }
                });
    }
}

3. 实例化时传入专属处理器 #

在创建EventProducerService实例时，指定泛型为OrderTrackingInfoEvent，并传入针对该类型的处理逻辑——此时编译器会自动约束类型，无需强制转换：

EventProducerService<OrderTrackingInfoEvent> orderEventProducer = new EventProducerService<>(
        httpClientWrapper, tokensFacade, WRITE_URL,
        topic, BUFFER_SIZE, vertx, metricRegistry,
        events -> {
            // 这里的events已经是List<OrderTrackingInfoEvent>类型，可直接调用专属方法
            for (OrderTrackingInfoEvent event : events) {
                String orderId = event.getOrderId();
                String trackingDetails = event.getTrackingDetails();
                // 执行发送到追踪服务的逻辑
                trackingService.send(orderId, trackingDetails);
            }
        }
);

核心原理 #

通过泛型约束+函数式接口的组合，让处理器在编译期就确定要处理的事件类型，既避免了强制类型转换的风险，又让代码具备扩展性——如果后续需要处理其他类型的事件，只需创建对应泛型的EventProducerService实例，传入专属处理器即可。

内容的提问来源于stack exchange，提问作者Lokraj Ahuja