Java Kafka将如何将对象转换为两个对象，并使用一个对象作为键，另一个对象作为groupBy的值

正如标题所述，我遇到了一个问题，我收到了一个完整的对象，我想把它分成两个对象，一个是标题，另一个是如下所示的值：

public class Pipeline {

    // @JsonIgnoreProperties({ "schema" })
    static public class Message {
        @JsonIgnore
        public Object schema;
        public initialPurchaseOrder payload;
    }

    static public class initialPurchaseOrder {
        public Timestamp CHANGED_TIMESTAMP;
        public String EBELN;
        public String AEDAT;
        public String WAERS;
        public String LASTCHANGEDATETIME;
        public String MANDT;
        public String LAND1;
        public String BATXT;
        public String EKOTX;
        public Double CALC_MENGE;
        public Double CALC_NETWR;
        public String EBELP;
        public String TXZ01;
        public String WGBEZ;
        public String MEINS;
        public String MENGE;
        public String NETWR;
        public String LOEKZ;
    }

    static public class orderHeader {
        public String EBELN;
        public String AEDAT;
        public String WAERS;
        public String EKOTX;
        public String BATXT;
        public String LAND1;
    }

    static public class orderItem {
        public String EBELP;
        public Double CALC_NETWR;
        public String TXZ01;
        public Double CALC_MENGE;
        public String MEINS;
        public String WGBEZ;
        public String LOEKZ;
    }

    static public class finalPurchaseOrder {
        public orderHeader header;
        public ArrayList<orderItem> items;
    }

    public static void main(final String[] args) {

        final Properties props = new Properties();
        props.put(StreamsConfig.APPLICATION_ID_CONFIG, "streams-pipe");
        props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass().getName());
        props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass().getName());

        final Map<String, Object> serdeProps = new HashMap<>();

        final Serializer<Message> MessageSerializer = new JsonPOJOSerializer<>();
        serdeProps.put("JsonPOJOClass", Message.class);
        MessageSerializer.configure(serdeProps, false);

        final Deserializer<Message> MessageDeserializer = new JsonPOJODeserializer<>();
        serdeProps.put("JsonPOJOClass", Message.class);
        MessageDeserializer.configure(serdeProps, false);

        final StreamsBuilder builder = new StreamsBuilder();
        final Serde<String> stringSerdes = Serdes.String();

        final Serde<Message> MessageSerde = Serdes.serdeFrom(MessageSerializer, MessageDeserializer);
        final KStream<String, Message> source = builder.stream("testTopic", Consumed.with(stringSerdes, MessageSerde));

        final KGroupedStream<String, initialPurchaseOrder> groupedStream = source.map((k, v) -> KeyValue.pair(v.payload.EBELN, v.payload))
                .peek((k, v) -> System.out.printf("After keying: "+ k + ", value: " + v.toString() +"\n"))
                .groupByKey();

        source.to("output1");

公共类管道{
//@JsonIgnoreProperties（{“schema”}）
静态公共类消息{
@杰索尼奥雷
公共对象模式；
公共初始采购订单有效载荷；
}
静态公共类initialPurchaseOrder{
公共时间戳已更改\u时间戳；
公共字符串EBELN；
公共字符串AEDAT；
公共字符串生成器；
公共字符串LASTCHANGEDATETIME；
公共字符串命令；
公共字符串1；
公共字符串BATXT；
公共字符串EKOTX；
公共双计算；
公共双计算网络；
公共字符串EBELP；
公用串TXZ01；
公共字符串WGBEZ；
公共字符串；
公共字符串MENGE；
公共字符串网络；
公共字符串LOEKZ；
}
静态公共类orderHeader{
公共字符串EBELN；
公共字符串AEDAT；
公共字符串生成器；
公共字符串EKOTX；
公共字符串BATXT；
公共字符串1；
}
静态公共类orderItem{
公共字符串EBELP；
公共双计算网络；
公用串TXZ01；
公共双计算；
公共字符串；
公共字符串WGBEZ；
公共字符串LOEKZ；
}
静态公共类finalPurchaseOrder{
公共命令头；
公共阵列列表项；
}
公共静态void main（最终字符串[]args）{
最终属性道具=新属性（）；
props.put（StreamsConfig.APPLICATION_ID_CONFIG，“streams管道”）；
put（StreamsConfig.BOOTSTRAP_SERVERS_CONFIG，“localhost:9092”）；
props.put（StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG，Serdes.String（）.getClass（）.getName（））；
props.put（StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG，Serdes.String（）.getClass（）.getName（））；
final Map serdeProps=new HashMap（）；
final Serializer MessageSerializer=new JsonPOJOSerializer（）；
serdeProps.put（“JsonPOJOClass”，Message.class）；
MessageSerializer.configure（serdeProps，false）；
最终反序列化器MessageDeserializer=新的JsonPOJODeserializer（）；
serdeProps.put（“JsonPOJOClass”，Message.class）；
MessageDeserializer.configure（serdeProps，false）；
最终StreamsBuilder生成器=新StreamsBuilder（）；
final Serde stringSerdes=Serdes.String（）；
final Serde MessageSerde=Serdes.serdeFrom（MessageSerializer，MessageDeserializer）；
最终KStream source=builder.stream（“testTopic”，consumered.with（stringSerdes，MessageSerde））；
最终KGroupedStream groupedStream=source.map（（k，v）->KeyValue.pair（v.payload.EBELN，v.payload））
.peek（（k，v）->System.out.printf（“键入后：“+k+”，值：“+v.toString（）+”\n”））
.groupByKey（）；
来源。至（“输出1”）；

这里的问题是，目前我甚至无法将initialPurchaseOrder对象拆分为orderHeader和orderItem

---

之后，我应该能够映射这两个对象并对它们进行分组。

您已经有了

KStream

。只需使用

map（）

并将相应的构造函数添加到

类orderHeader

和

类orderItem

：

最终KStream源=
stream（“testTopic”，consumered.with（stringSerdes，MessageSerde））
map（（k，v）->KeyValue.pair（v.payload.EBELN，v.payload））；
溪流=
map（（k，v）->（新订单头（v），新订单项（v））；

与：

类orderHeader{
orderHeader（initialPurchaseOrder ipo）{
EBELN=iop.EBELN；
AEDAT=iop.AEDAT；
//...
}
}
//类似于` orderItem`