Java Kafka流处理翻滚窗口

我正在使用JavaKStream API处理消息流。目前，我的代码每5分钟发出一次输出，但我希望在5分钟间隔的顶部发出输出（如17:10、17:15等）

目前，间隔取决于程序启动的时间。如果程序在17:08开始，数据将在17:13、17:18、17:23等时间间隔收集

是否有一种方法可以安排数据以5分钟的间隔（5的倍数）发出

class WindowedTransformerExample {

public static void main(String[] args) {
final StreamsBuilder builder = new StreamsBuilder();

final String stateStoreName = "stateStore";
final StoreBuilder<KeyValueStore<String, String>> keyValueStoreBuilder =
    Stores.keyValueStoreBuilder(Stores.inMemoryKeyValueStore(stateStoreName),
        Serdes.String(),
        Serdes.String());

builder.addStateStore(keyValueStoreBuilder);

   builder.<String, String>stream("topic").transform(new 
     WindowedTransformer(stateStoreName), stateStoreName)
    .filter((k, v) -> k != null && v != null)
       // Here's where you do something with records emitted after 10 minutes
    .foreach((k, v)-> System.out.println());
}


static final class WindowedTransformer implements TransformerSupplier<String, String, KeyValue<String, String>> {

private final String storeName;

public WindowedTransformer(final String storeName) {
     this.storeName = storeName;
}

@Override
public Transformer<String, String, KeyValue<String, String>> get() {
  return new Transformer<String, String, KeyValue<String, String>>() {
    private KeyValueStore<String, String> keyValueStore;
    private ProcessorContext processorContext;

    @Override
    public void init(final ProcessorContext context) {
      processorContext = context;
      keyValueStore = (KeyValueStore<String, String>) context.getStateStore(storeName);
      // could change this to PunctuationType.STREAM_TIME if needed
      context.schedule(Duration.ofMinutes(5), PunctuationType.WALL_CLOCK_TIME, (ts) -> {
        try(final KeyValueIterator<String, String> iterator = keyValueStore.all()) {
            while (iterator.hasNext()) {
              final KeyValue<String, String> keyValue = iterator.next();
              processorContext.forward(keyValue.key, keyValue.value);
            }
        }
      });
    }

    @Override
    public KeyValue<String, String> transform(String key, String value) {
      if (key != null) {
        keyValueStore.put(key, value);
      }
      return null;
    }

    @Override
    public void close() {

    }
  };
  }
}

class WindowedTransformerExample{
公共静态void main（字符串[]args）{
最终StreamsBuilder生成器=新StreamsBuilder（）；
最后一个字符串stateStoreName=“stateStore”；
最终StoreBuilder键值StoreBuilder=
Stores.keyValueStoreBuilder（Stores.inMemoryKeyValueStore（stateStoreName），
Serdes.String（），
Serdes.String（））；
builder.addStateStore（keyValueStoreBuilder）；
builder.stream（“主题”）.transform（新
窗口变压器（stateStoreName），stateStoreName）
.filter（（k，v）->k！=null&&v！=null）
//这里是处理10分钟后发出的记录的地方
.foreach（（k，v）->System.out.println（））；
}
静态最终类WindowedTransformer实现TransformerSupplier{
私有最终字符串storeName；
公共窗口变压器（最终字符串存储名）{
this.storeName=storeName；
}
@凌驾
公共变压器get（）{
返回新变压器（）{
private KeyValueStore KeyValueStore；
私有处理器Context处理器Context；
@凌驾
public void init（最终处理器上下文）{
processorContext=上下文；
keyValueStore=（keyValueStore）context.getStateStore（storeName）；
//如果需要，可以将此更改为标点类型.STREAM\u TIME
上下文.时间表（持续时间.分钟（5），标点类型.挂钟时间（ts）->{
try（final KeyValueIterator iterator=keyValueStore.all（））{
while（iterator.hasNext（））{
final KeyValue KeyValue=iterator.next（）；
processorContext.forward（keyValue.key，keyValue.value）；
}
}
});
}
@凌驾
公钥值转换（字符串键、字符串值）{
if（key！=null）{
keyValueStore.put（键，值）；
}
返回null；
}
@凌驾
公众假期结束（）{
}
};
}
}

}