Java 具有单个执行器的发布-订阅通道

我有一个集成流绑定到云流输入通道 卡夫卡

然后消息通过singleThreadExecutor进入publishSubscribe通道

从那里，他们去一个用户处理他们。处理可能需要一些时间

据我所知，处理是在singleThreadExecutor上完成的。云流的线程被释放，可以从卡夫卡那里获取另一条消息

如果新消息到达但处理线程仍然繁忙，会发生什么？ 云数据流的线程将等待还是消息将被丢弃？ 如果要等多久？是否有一些默认的超时值

我有一个猜测，我们失去了一些消息在这种情况下，因为我可以看到消息在卡夫卡，但没有相应的更新在数据库

但大多数消息都按预期进行了处理

public interface PointChannelProcessor {
    @Input("point-channel")
    MessageChannel pointChannel();
}

@Bean
public MessageChannel routeByKeyMessageChannel() {
    return MessageChannels.publishSubscribe(Executors.newSingleThreadExecutor()).get();
}

@Bean
public IntegrationFlow retrievePointListFromKafka() {
    return IntegrationFlows.from(pointChannelProcessor.pointChannel())
        .transform(new JsonToObjectTransformer(PointKafkaImport.class))
        .channel(ROUTE_BY_KEY_MESSAGE_CHANNEL)
        .get();
}

@Bean
public IntegrationFlow routePointsByKey(){
    return IntegrationFlows.from(ROUTE_BY_KEY_MESSAGE_CHANNEL)
        .enrichHeaders(e -> e.header(MessageHeaders.ERROR_CHANNEL, failedPointsChannel(), true))
        .route((GenericHandler<PointKafkaImport>) (payload, headers) -> {
              //some routing logic
              if (...) {
                  return ONE_CHANNEL;
              } else if (...){
                  return NULL_CHANNEL;
              } else {
                  return ANOTHER_CHANNEL;
              }
        })
        .get();
}

//Other direct channels from routing which handles payload
@Bean
public IntegrationFlow savePoint(){
    return IntegrationFlows.from(ONE_CHANNEL)
        .handle((GenericHandler<PointKafkaImport>) (payload, headers) -> ...)
        .get();
}

@Bean
public IntegrationFlow updatePoint(){
    return IntegrationFlows.from(ANOTHER_CHANNEL)
        .handle((GenericHandler<PointKafkaImport>) (payload, headers) -> ...)
        .get();
}

公共接口点通道处理器{
@输入（“点通道”）
MessageChannel pointChannel（）；
}
@豆子
public MessageChannel routeByKeyMessageChannel（）{
return MessageChannels.publishSubscribe（Executors.newSingleThreadExecutor（））.get（）；
}
@豆子
来自Kafka（）的公共集成流检索点列表{
返回IntegrationFlows.from（pointChannelProcessor.pointChannel（））
.transform（新的JsonToObjectTransformer（PointKafkaImport.class））
.频道（按按键发送消息频道）
.get（）；
}
@豆子
公共集成流路由PointsByKey（）{
返回IntegrationFlows.from（按密钥路由消息通道）
.enrichHeaders（e->e.header（MessageHeaders.ERROR_通道，FailedPointsAnnel（），true））
.路线（（通用装卸工）（有效载荷、头）->{
//一些路由逻辑
如果（…）{
返回一个_通道；
}否则如果（…）{
返回空_通道；
}否则{
返回另一个_频道；
}
})
.get（）；
}
//处理有效负载的路由的其他直接通道
@豆子
公共集成流保存点（）{
返回IntegrationFlows.from（一个通道）
.handle（（通用装卸工）（有效载荷、收割台）->…）
.get（）；
}
@豆子
公共集成流更新点（）{
返回IntegrationFlows.from（另一个_通道）
.handle（（通用装卸工）（有效载荷、收割台）->…）
.get（）；
}

您需要更清楚地了解您的问题，但据我所知，请确保您找到

发布订阅

和

生产者消费者

。在Kafka中，代码负责从队列中拾取消息，而消息不会发送到代码。因此，您的代码不能忙于从队列中拾取消息

---

此外，有许多策略可以确保您从队列中读取和处理数据，并且不会丢失任何数据。在consumer中，您只需读取消息并增加偏移量，如果处理失败，您可以再次读取消息。设置Kafka时设置的策略将删除这些消息。

谢谢，但我的问题是关于Spring集成，而不是Kafka。它可以是任何消息生成器。