Java 阿克卡河。为UniformFanOutShape实现自定义逻辑

我试图实现UniformFanOutShape的自定义逻辑，但似乎我做错了什么。我的目标是实现自定义形状，它将根据消息中的数据将消息重定向到正确的出口

public class SPMessageSplitter extends GraphStage<UniformFanOutShape<SPFinderData,SPFinderData>> {

    //Inlet
    public final Inlet<SPFinderData> in = Inlet.create("Inlet.in");

    //Outlets
    public final Outlet<SPFinderData> flOut = Outlet.create("FL.out");
    public final Outlet<SPFinderData> sOut = Outlet.create("SD.out");
    public final Outlet<SPFinderData> cOut = Outlet.create("CD.out");

    private Outlet[] outlets = {flOut, sOut, cOut};

    //Shape
    private final UniformFanOutShape<SPFinderData, SPFinderData> shape = new UniformFanOutShape<>(in, (Outlet<SPFinderData>[])outlets);

    @Override
    public UniformFanOutShape<SPFinderData, SPFinderData> shape() {
        return shape;
    }

    @Override
    public GraphStageLogic createLogic(Attributes inheritedAttributes) {
        return new GraphStageLogic(shape) {
            IntReplacement pendingCount = new IntReplacement(3);
            IntReplacement downstreamRunning = new IntReplacement(3);

            BoolReplacement pending0 = BoolReplacement.TRUE;
            BoolReplacement pending1 = BoolReplacement.TRUE;
            BoolReplacement pending2 = BoolReplacement.TRUE;

            //In handler
            {
                setHandler(in, new AbstractInHandler() {
                    @Override
                    public void onPush() throws Exception {
                        SPFinderData elem = grab(in);
                        System.out.print("Splitter: ON PUSH!");
                        push(findOutlet(elem), elem);
                        pendingCount.setInteger(downstreamRunning.getInteger());
                    }
                });
            }

            //Handler for FL.out outlet
            {
                setHandler(flOut, new AbstractOutHandler() {
                    @Override
                    public void onPull() throws Exception {
                        {
                            pendingCount.setInteger(pendingCount.getInteger() - 1);
                            pending0.setValue(false);
                            if (pendingCount.getInteger() == 0) pull(in);
                        }
                    }

                    @Override
                    public void onDownstreamFinish() {
                        downstreamRunning.setInteger(downstreamRunning.getInteger() - 1);
                        if (downstreamRunning.getInteger() == 0) completeStage();
                        else {
                            if (pending0.getBoolValue()) pendingCount.setInteger(pendingCount.getInteger() - 1);
                            if (pendingCount.getInteger() == 0 && !hasBeenPulled(in)) pull(in);
                        }
                    }
                });
            }
            //Handler for SD.out outlet
            {
                setHandler(sOut, new AbstractOutHandler() {
                    @Override
                    public void onPull() throws Exception {
                        {
                            pendingCount.setInteger(pendingCount.getInteger() - 1);
                            pending1.setValue(false);
                            if (pendingCount.getInteger() == 0) pull(in);
                        }
                    }

                    @Override
                    public void onDownstreamFinish() {
                        downstreamRunning.setInteger(downstreamRunning.getInteger() - 1);
                        if (downstreamRunning.getInteger() == 0) completeStage();
                        else {
                            if (pending1.getBoolValue()) pendingCount.setInteger(pendingCount.getInteger() - 1);
                            if (pendingCount.getInteger() == 0 && !hasBeenPulled(in)) pull(in);
                        }
                    }
                });
            }
            //Handler for CDir.out outlet
            {
                setHandler(cOut, new AbstractOutHandler() {
                    @Override
                    public void onPull() throws Exception {
                        {
                            pendingCount.setInteger(pendingCount.getInteger() - 1);
                            pending2.setValue(false);
                            if (pendingCount.getInteger() == 0) pull(in);
                        }
                    }

                    @Override
                    public void onDownstreamFinish() {
                        downstreamRunning.setInteger(downstreamRunning.getInteger() - 1);
                        if (downstreamRunning.getInteger() == 0) completeStage();
                        else {
                            if (pending2.getBoolValue()) pendingCount.setInteger(pendingCount.getInteger() - 1);
                            if (pendingCount.getInteger() == 0 && !hasBeenPulled(in)) pull(in);
                        }
                    }
                });
            }

        };
    }

    private Outlet<SPFinderData> findOutlet(SPFinderData elem) {
        if(elem.isF() || elem.isL()) {
            System.out.println("Splitte: Redirect to FL.");
            return flOut;
        } else if(!elem.getCD()) {
            System.out.println("Splitte: Redirect to S.");
            return sOut;
        }
        System.out.println("Splitte: Redirect to C.");
        return cOut;
    }
}

public类SPMessageSplitter扩展了GraphStage{
//入口
公共最终入口in=入口.create（“入口.in”）；
//出口
公共最终出口flOut=出口。创建（“FL.out”）；
公共最终出口sOut=Outlet.create（“SD.out”）；
公共最终出口cOut=Outlet.create（“CD.out”）；
私人出口[]出口={flOut，sOut，cOut}；
//形状
专用最终UniformFanOutShape=新的UniformFanOutShape（in，（Outlet[]）outlets）；
@凌驾
公共UniformFanOutShape形状（）{
返回形状；
}
@凌驾
公共图形标记逻辑createLogic（属性继承属性）{
返回新GraphStageLogic（形状）{
IntReplacement pendingCount=新IntReplacement（3）；
IntReplacement下游运行=新IntReplacement（3）；
BoolReplacement pending0=BoolReplacement.TRUE；
BoolReplacement pending1=BoolReplacement.TRUE；
BoolReplacement pending2=BoolReplacement.TRUE；
//内处理程序
{
setHandler（在，新的AbstractInHandler（）中）{
@凌驾
public void onPush（）引发异常{
SPFinderData元素=抓取（in）；
System.out.print（“拆分器：按下！”）；
推（芬多特（elem），elem）；
pendingCount.setInteger（下行运行.getInteger（））；
}
});
}
//FL.out出口处理装置
{
setHandler（flOut，新的AbstractOutHandler（）{
@凌驾
public void onPull（）引发异常{
{
setInteger（pendingCount.getInteger（）-1）；
pending0.setValue（假）；
如果（pendingCount.getInteger（）==0）拉入（in）；
}
}
@凌驾
公共无效onDownstreamFinish（）{
downstreamRunning.setInteger（downstreamRunning.getInteger（）-1）；
如果（downstreamRunning.getInteger（）==0）CompleteTasage（）；
否则{
if（pending0.getBoolValue（））pendingCount.setInteger（pendingCount.getInteger（）-1）；
如果（pendingCount.getInteger（）==0&&！hasBeenPulled（in））拉入（in）；
}
}
});
}
//SD.out出口的处理程序
{
setHandler（sOut，新的AbstractOutHandler（）{
@凌驾
public void onPull（）引发异常{
{
setInteger（pendingCount.getInteger（）-1）；
pending1.设置值（假）；
如果（pendingCount.getInteger（）==0）拉入（in）；
}
}
@凌驾
公共无效onDownstreamFinish（）{
downstreamRunning.setInteger（downstreamRunning.getInteger（）-1）；
如果（downstreamRunning.getInteger（）==0）CompleteTasage（）；
否则{
if（pending1.getBoolValue（））pendingCount.setInteger（pendingCount.getInteger（）-1）；
如果（pendingCount.getInteger（）==0&&！hasBeenPulled（in））拉入（in）；
}
}
});
}
//CDir.out出口的处理程序
{
setHandler（cOut，新的AbstractOutHandler（）{
@凌驾
public void onPull（）引发异常{
{
setInteger（pendingCount.getInteger（）-1）；
pending2.设置值（假）；
如果（pendingCount.getInteger（）==0）拉入（in）；
}
}
@凌驾
公共无效onDownstreamFinish（）{
downstreamRunning.setInteger（downstreamRunning.getInteger（）-1）；
如果（downstreamRunning.getInteger（）==0）CompleteTasage（）；
否则{
if（pending2.getBoolValue（））pendingCount.setInteger（pendingCount.getInteger（）-1）；
如果（pendingCount.getInteger（）==0&&！hasBeenPulled（in））拉入（in）；
}
}
});
}
};
}
专用插座findOutlet（SPFinderData elem）{
if（elem.isF（）| | elem.isL（））{
System.out.println（“拆分：重定向到佛罗里达州”）；
返回藐视；
}else如果（！elem.getCD（））{
System.out.println（“拆分：重定向到S”）；
返回sOut；
}
System.out.println（“拆分：重定向到C.”）；
返回cOut；
}
}

我已经从数组中创建了Sink，其中包含49个元素。我还将loggin放入几乎所有形状的onPush和onPull函数中。但结果是，我新创建的形状只处理4条消息，然后停止从入口拉出，所以消息被卡在水槽中。你能帮我修一下吗？ 提前谢谢你

干杯，

---

Sergey

你检查过分区阶段（）是否解决了你的问题吗？这正是我想要的。谢谢你检查过分区阶段（）是否解决了你的问题吗？这正是我想要的。谢谢