Apache flink Flink reduce键控非窗口流

我使用的是键控的非窗口流。 尝试将上述流化对象缩减为一，方法是将该对象中的变量相加并返回该对象，从而将两个值缩减为一。下面是一个例子

例如，有两个对象，object1和object2都有count变量

object1 -> 
    name
    count
object2 ->
    name
    count

Flink键控的非窗口减少函数实际上并不是减少并返回一个对象。它同时返回两个对象：原样的object1和更新计数的object2

deDupedStream.keyBy(msg -> keyConstruct())
.reduce((ReduceFunction<Object>) (value1, value2) -> {
    value2.setCount(value1.getCount() + value2.getCount());
    return value2;
})

我所期望的只是返回更新的对象，而不是同时返回这两个对象。这就是我假设的减少。有谁能建议我如何只输出更新的版本吗

更新：上述聚合步骤之前的逻辑：重复数据消除

SingleOutputStreamOperator<Object> deDupedStream = inputStream.keyBy(new DeDupKeyConstructor())
                .timeWindow(Time.milliseconds(timeWindowInMillis))
                .reduce(new DedupReduceFunction(), new DedupProcessFunction());

SingleOutputStreamOperator dedupledStream=inputStream.keyBy（新的DeDupKeyConstructor（））
.timeWindow（时间.毫秒（时间窗单位：毫秒））
.reduce（新的DedupReduceFunction（），新的DedupProcessFunction（））；

重复数据处理函数.java

public class DedupProcessFunction extends ProcessWindowFunction<Class1, Class1, String, TimeWindow> {

    @Override
    public void process(String key, Context context, Iterable<Class1> in, Collector<Class1> out) throws Exception {
        Class1 obj = in.iterator().next();
        obj.setWindowStartTime(context.window().getStart());
        out.collect(obj);
    }
}

public class DedupReduceFunction implements ReduceFunction<Class1> {
    @Override
    public Class1 reduce(Class1 value1, Class1 value2) throws Exception {
        return value1.getEventTimeStamp() > value2.getEventTimeStamp() ? value1 : value2;
    }
}

public class AggregateProcessFunction extends ProcessWindowFunction<Class1, Class1, String, TimeWindow> {

    @Override
    public void process(String key, Context context, Iterable<Class1> in, Collector<Class1> out) throws Exception {
        out.collect(in.iterator().next());
    }
}

public class AggregateReduceFunction implements ReduceFunction<Class1> {
    @Override
    public Class1 reduce(Class1 value1, Class1 value2) {
        Class1 value =  value1.getEventTimeStamp() > value2.getEventTimeStamp() ? value1 : value2;
        value.setCount(value1.getCount() + value2.getCount());
        return value;
    }
}

公共类DedupProcessFunction扩展了ProcessWindowFunction{
@凌驾
公共void进程（字符串键、上下文上下文、Iterable in、收集器out）引发异常{
Class1 obj=in.iterator（）.next（）；
obj.setWindowsStartTime（context.window（）.getStart（））；
输出。收集（obj）；
}
}

dedupleReduceFunction.java

public class DedupProcessFunction extends ProcessWindowFunction<Class1, Class1, String, TimeWindow> {

    @Override
    public void process(String key, Context context, Iterable<Class1> in, Collector<Class1> out) throws Exception {
        Class1 obj = in.iterator().next();
        obj.setWindowStartTime(context.window().getStart());
        out.collect(obj);
    }
}

public class DedupReduceFunction implements ReduceFunction<Class1> {
    @Override
    public Class1 reduce(Class1 value1, Class1 value2) throws Exception {
        return value1.getEventTimeStamp() > value2.getEventTimeStamp() ? value1 : value2;
    }
}

public class AggregateProcessFunction extends ProcessWindowFunction<Class1, Class1, String, TimeWindow> {

    @Override
    public void process(String key, Context context, Iterable<Class1> in, Collector<Class1> out) throws Exception {
        out.collect(in.iterator().next());
    }
}

public class AggregateReduceFunction implements ReduceFunction<Class1> {
    @Override
    public Class1 reduce(Class1 value1, Class1 value2) {
        Class1 value =  value1.getEventTimeStamp() > value2.getEventTimeStamp() ? value1 : value2;
        value.setCount(value1.getCount() + value2.getCount());
        return value;
    }
}

公共类DedupReduceFunction实现ReduceFunction{
@凌驾
公共类1 reduce（类1值1、类1值2）引发异常{
返回值1.getEventTimeStamp（）>value2.getEventTimeStamp（）？value1:value2；
}
}

上面的流实际上是收集1小时的数据并删除其中的重复项

下面，我尝试执行聚合。实际上我正在尝试的是，我是否能够将这两种逻辑组合到一个窗口中。我们还假设两个键构造函数是相同的。如果我尝试将两者结合到一个窗口逻辑中，我可以减少作业中的运算符数量。这就是我如何开始尝试移除一个窗口并查看它的行为。如果这是不可能的，我如何将两个逻辑组合成一个（假设密钥分组逻辑几乎相同（在aggregateKeyConstructor中仅从DeDupKeyConstructor中删除一个变量））

SingleOutputStreamOperator aggregatedStream=重复数据流
.keyBy（aggregateKeyConstructor（））
.timeWindow（时间.毫秒（时间窗单位：毫秒））
.reduce（新的AggregateReduceFunction（），新的AggregateProcessFunction（））；

AggregateProcessFunction.java

public class DedupProcessFunction extends ProcessWindowFunction<Class1, Class1, String, TimeWindow> {

    @Override
    public void process(String key, Context context, Iterable<Class1> in, Collector<Class1> out) throws Exception {
        Class1 obj = in.iterator().next();
        obj.setWindowStartTime(context.window().getStart());
        out.collect(obj);
    }
}

public class DedupReduceFunction implements ReduceFunction<Class1> {
    @Override
    public Class1 reduce(Class1 value1, Class1 value2) throws Exception {
        return value1.getEventTimeStamp() > value2.getEventTimeStamp() ? value1 : value2;
    }
}

public class AggregateProcessFunction extends ProcessWindowFunction<Class1, Class1, String, TimeWindow> {

    @Override
    public void process(String key, Context context, Iterable<Class1> in, Collector<Class1> out) throws Exception {
        out.collect(in.iterator().next());
    }
}

public class AggregateReduceFunction implements ReduceFunction<Class1> {
    @Override
    public Class1 reduce(Class1 value1, Class1 value2) {
        Class1 value =  value1.getEventTimeStamp() > value2.getEventTimeStamp() ? value1 : value2;
        value.setCount(value1.getCount() + value2.getCount());
        return value;
    }
}

公共类AggregateProcessFunction扩展了ProcessWindowFunction{
@凌驾
公共void进程（字符串键、上下文上下文、Iterable in、收集器out）引发异常{
out.collect（in.iterator（）.next（））；
}
}

AggregateReduceFunction.java

public class DedupProcessFunction extends ProcessWindowFunction<Class1, Class1, String, TimeWindow> {

    @Override
    public void process(String key, Context context, Iterable<Class1> in, Collector<Class1> out) throws Exception {
        Class1 obj = in.iterator().next();
        obj.setWindowStartTime(context.window().getStart());
        out.collect(obj);
    }
}

public class DedupReduceFunction implements ReduceFunction<Class1> {
    @Override
    public Class1 reduce(Class1 value1, Class1 value2) throws Exception {
        return value1.getEventTimeStamp() > value2.getEventTimeStamp() ? value1 : value2;
    }
}

public class AggregateProcessFunction extends ProcessWindowFunction<Class1, Class1, String, TimeWindow> {

    @Override
    public void process(String key, Context context, Iterable<Class1> in, Collector<Class1> out) throws Exception {
        out.collect(in.iterator().next());
    }
}

public class AggregateReduceFunction implements ReduceFunction<Class1> {
    @Override
    public Class1 reduce(Class1 value1, Class1 value2) {
        Class1 value =  value1.getEventTimeStamp() > value2.getEventTimeStamp() ? value1 : value2;
        value.setCount(value1.getCount() + value2.getCount());
        return value;
    }
}

公共类AggregateReduceFunction实现了ReduceFunction{
@凌驾
公共1类减少（1类价值1、1类价值2）{
Class1 value=value1.getEventTimeStamp（）>value2.getEventTimeStamp（）？value1:value2；
value.setCount（value1.getCount（）+value2.getCount（））；
返回值；
}
}

这是一个滚动减少：当第一个元素出现时，还没有任何东西可以减少它，因此它作为初始值发出。如果你期望这里只有一个值，那么当它是3，4。。。元素要减少而不是两个？我仍然希望只有一个对象作为输出，如果该键控组中有N个对象。我的想法是，是否可以选择不发射第一个对象，而只发射更新的对象。我正在检查不使用窗口的可能性。如果同一个键控组中的N个对象仍应产生单个输出，下一个逻辑问题是：如何知道键控组的最后一个元素何时到达无界流，以便现在可以发出结果？我认为您需要针对您的用例回答这个问题，然后实现一个定制的富函数来进行聚合。我力所能及地提供整个代码，感觉可能不需要。但在你的问题中，我应该包括这个逻辑。让我更新这个问题，看看我在这次聚集之前做了什么