Java 一对多KStream KStream加入

如何在两个kafka KStream之间执行一对多连接？ 下面给出的代码以一对一的方式连接两个Kafka KStream。 是否有人可以指导如何在KStream之间执行一对多连接？ 主题中接收到的数据是泛型 在主题中写入的数据的格式为 {“来自订单”：“test1:，”来自订单项”：“test2”} {“来自订单”：“test1:，”来自订单项”：“test3”}

是否可以以这种格式获取数据： {“来自订单”：“test1，{”来自订单项”：“test2”}，{“来自订单项”：“test3”}

公共类ConsumerReadPool{
私有静态最终字符串TOPIC=“jre1”；
私有静态最终字符串NEXTTOPIC=“Kafka”；
私有静态最终字符串FINALTOPIC=“jvm1”；
私有静态最终整数NUM_THREADS=1；
最终序列化程序jsonSerializer=新的jsonSerializer（）；
最终反序列化程序jsonDeserializer=新的jsonDeserializer（）；
final-Serde-jsonSerde=Serdes.serdeFrom（jsonSerializer、jsonSerializer）；
final Serde stringSerde=Serdes.String（）；
int threadNumber=0；
@自动连线
私人消费者配置工厂消费者配置工厂；
@抑制警告（“未使用”）
私人消费者连接消费者；
私人服务线程池；
公共用户阅读池（）{
threadPool=Executors.newFixedThreadPool（NUM_线程）；
}
@施工后
公共无效开始消费（）{
ConsumerConfig ConsumerConfig=consumerConfigFactory.getConsumerConfig（）；
consumer=createJavaConsumerConnector（consumerConfig）；
KStreamBuilder builder=新的KStreamBuilder（）；
/*KTable message=builder.table（stringSerde、jsonSerde、TOPIC）；
KTable orderstream=消息
.filter（（k，v）->v.path（“表”）.asText（）.equals（“TEST.S_顺序”）
);              
KTable orderlist=message.filter（（k，v）->v.path（“表”）.asText（）.equals（“TEST.S_ORDER_ITEM”）；
to（stringSerde、jsonSerde、FINALTOPIC）；
orderlist.to（stringSerde、jsonSerde、FINALTOPIC）；*/
KStreamstreams=builder.stream（主题）；
KStream orderstream=streams.filter（（k，v）->v.path（“表”）.asText（）.equals（“TEST.S_顺序”））
.map（（k，v）->KeyValue.pair（v.path（“after”）.path（“ROW_ID”）.astex（），v））；
KStream orderlist=streams.filter（（k，v）->v.path（“表”）.asText（）.equals（“TEST.S_ORDER_ITEM”））
.map（（k，v）->KeyValue.pair（v.path（“after”）.path（“ORDER_ID”）.astex（），v））；
KStream nextstream=orderstream.join（orderlist，（new ValueJoiner（））{
@凌驾
公共JsonNode应用（JsonNode第一，JsonNode第二）{
ObjectNode jNode=JsonNodeFactory.instance.ObjectNode（）；
返回jNode.put（“从订单”，first.get（“op_type”）.textValue（））
.put（“from orderitem”，second.get（“op_type”）.textValue（）；
}
})，JoinWindows.of（TimeUnit.SECONDS.toMillis（30）），stringSerde，jsonSerde，jsonSerde）；
下一个流程到（stringSerde、jsonSerde、FINALTOPIC）；
KafkaStreams stream=新的KafkaStreams（生成器，consumerConfigFactory.getConsumerConfig（））；
stream.start（）；
消费（）；
stream.close（）；
}
公共消费（）{
@抑制警告（“资源”）
KafkaConsumer consumer=新的KafkaConsumer（consumerConfigFactory.createconsumer（））；
consumer.subscribe（Arrays.asList（FINALTOPIC））；
while（true）{
ConsumerRecords记录=consumer.poll（100）；
如果（！records.isEmpty（））{
System.out.println（“创建的消费者记录对象：“+记录”）；
submit（newmessageconsumer（记录，threadNumber））；
threadNumber++；
}
}
}    

---

}

正如您已经指出的，KStream KStream已经是一对多连接。您似乎希望将唯一键的所有连接结果聚合到一个记录中

---

您可以应用

.groupByKey（）.aggregate（）

执行此操作。聚合函数用空JSON初始化，每次新的联接结果到达时，都会向JSON中添加新记录。

正如您已经指出的，KStream KStream已经是一对多联接。您似乎希望将唯一键的所有联接结果聚合到一个记录中

您可以应用

.groupByKey（）.aggregate（）

来执行此操作。聚合函数使用空JSON初始化，每次新的连接结果到达时，都会向JSON添加新记录

public class ConsumerThreadPool {

private static final String TOPIC = "jre1";
private static final String NEXTTOPIC ="Kafka";
private static final String FINALTOPIC="jvm1";
private static final Integer NUM_THREADS = 1;
final Serializer<JsonNode> jsonSerializer = new JsonSerializer();
final Deserializer<JsonNode> jsonDeserializer = new JsonDeserializer();

final Serde<JsonNode> jsonSerde = Serdes.serdeFrom(jsonSerializer, jsonDeserializer);
final Serde<String> stringSerde = Serdes.String();


int threadNumber = 0;
@Autowired
private ConsumerConfigFactory consumerConfigFactory;

@SuppressWarnings("unused")
private ConsumerConnector consumer;
private ExecutorService threadPool;

public ConsumerThreadPool() {
    threadPool = Executors.newFixedThreadPool(NUM_THREADS);
}

@PostConstruct
public void startConsuming() {
    ConsumerConfig consumerConfig = consumerConfigFactory.getConsumerConfig();
    consumer = createJavaConsumerConnector(consumerConfig);
    KStreamBuilder builder = new KStreamBuilder();
    /* KTable<String,JsonNode> message = builder.table(stringSerde,jsonSerde,TOPIC);


    KTable<String,JsonNode> orderstream = message

            .filter((k,v)-> v.path("table").asText().equals("TEST.S_ORDER")
                    );              
    KTable<String,JsonNode> orderlist=message.filter((k,v)-> v.path("table").asText().equals("TEST.S_ORDER_ITEM"));
    orderstream.to(stringSerde,jsonSerde,FINALTOPIC);      
    orderlist.to(stringSerde,jsonSerde,FINALTOPIC);    */ 
    KStream<String,JsonNode>streams=builder.stream(TOPIC);

    KStream<String,JsonNode> orderstream=streams.filter((k,v)-> v.path("table").asText().equals("TEST.S_ORDER"))
            .map((k,v)->KeyValue.pair(v.path("after").path("ROW_ID").asText(),v));




    KStream<String, JsonNode> orderlist=streams.filter((k,v)-> v.path("table").asText().equals("TEST.S_ORDER_ITEM"))
            .map((k,v)->KeyValue.pair(v.path("after").path("ORDER_ID").asText(),v));





    KStream<String,JsonNode> nextstream =orderstream.join(orderlist,(new ValueJoiner<JsonNode,JsonNode,JsonNode>(){
        @Override
        public JsonNode apply(JsonNode first,JsonNode second){
            ObjectNode jNode = JsonNodeFactory.instance.objectNode();
            return jNode.put("from order",first.get("op_type").textValue())
                    .put("from orderitem",second.get("op_type").textValue() );
        }
    }),JoinWindows.of(TimeUnit.SECONDS.toMillis(30)),stringSerde,jsonSerde,jsonSerde);

    nextstream.to(stringSerde,jsonSerde,FINALTOPIC);  
    KafkaStreams stream=new KafkaStreams(builder, consumerConfigFactory.getConsumeConfig());
    stream.start();
    consume();
    stream.close();
}

public void consume() {



    @SuppressWarnings("resource")
    KafkaConsumer<String,String> consumer = new KafkaConsumer<>(consumerConfigFactory.createConsume());
    consumer.subscribe(Arrays.asList(FINALTOPIC));

    while (true) {
        ConsumerRecords<String, String> records = consumer.poll(100);
        if(!records.isEmpty()){
            System.out.println("ConsumerRecords object created: "+records);
            threadPool.submit(new MessageConsumer(records, threadNumber));
            threadNumber++;
        }

    }

}