骆驼聚合与完成谓词不起作用

Question

下面是我编写的示例代码。我期望它像下面的流程一样运行。但这不是

1）Proc1和Proc2将并行运行

2）每次聚合之后，它将调用谓词以检查完成谓词。如果谓词返回true，则聚合将完成。 此代码未调用AggregationStratergy中的谓词。

还尝试在路线（带有注释的代码）中使用completionPredicate，但该路由也无法正常工作。

骆驼版本：2.23.2 杰夫8

import org.apache.camel.AsyncCallback;
import org.apache.camel.AsyncProcessor;
import org.apache.camel.Exchange;
import org.apache.camel.Predicate;
import org.apache.camel.Produce;
import org.apache.camel.ProducerTemplate;
import org.apache.camel.builder.RouteBuilder;
import org.apache.camel.processor.aggregate.AggregationStrategy;
import org.apache.camel.testng.CamelTestSupport;
import org.apache.camel.util.AsyncProcessorHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.testng.annotations.Test;
import rx.Observable;
import rx.functions.Action1;
import rx.schedulers.Schedulers;


public class MyAggregation extends CamelTestSupport {

    private static final Logger LOGGER = LoggerFactory.getLogger(MyAggregation.class);

    @Produce(uri = "direct:start")
    protected ProducerTemplate template;

    @Test
    public void myAggregationTest() throws Exception {
        template.sendBody("message");
        }


    public class Proc1 implements AsyncProcessor {

        @Override
        public void process(final Exchange exchange) throws Exception {
            AsyncProcessorHelper.process(this, exchange);
        }

        @Override
        public boolean process(final Exchange exchange, final AsyncCallback callback) {

            LOGGER.debug("Proc 1 processing....");

            Observable.just(exchange.getIn().getBody().toString()).observeOn(Schedulers.io())
                    .subscribe(new Action1<String>() {
                        @Override
                        public void call(final String s) {
                            try {
                                LOGGER.debug("Sleeping Proc1 call");
                                Thread.sleep(500);
                            }catch(Exception e)
                            {
                                LOGGER.debug("Exception Proc1 call");
                            }
                            exchange.setProperty("AGG",true);
                            LOGGER.debug("Proc1 call completed");
                            callback.done(false);
                        }
                    });
            return false;
        }
    }

    public class Proc2 implements AsyncProcessor {

        @Override
        public void process(final Exchange exchange) throws Exception {
            AsyncProcessorHelper.process(this, exchange);
        }

        @Override
        public boolean process(final Exchange exchange, final AsyncCallback callback) {

            LOGGER.debug("Proc2 processing....");

            Observable.just(exchange.getIn().getBody().toString()).observeOn(Schedulers.io())
                    .subscribe(new Action1<String>() {
                        @Override
                        public void call(final String s) {
                            LOGGER.debug("Proc2 call");
                            callback.done(false);
                        }
                    });

            LOGGER.debug("Proc2 completed");
            return false;
        }
    }

    public class FinalProc implements AsyncProcessor {

        @Override
        public void process(final Exchange exchange) throws Exception {
            AsyncProcessorHelper.process(this, exchange);
        }

        @Override
        public boolean process(final Exchange exchange, final AsyncCallback callback) {
            LOGGER.debug("Final processing....");
            return true;
        }
    }
    @Override
    protected RouteBuilder createRouteBuilder() {
        return new RouteBuilder() {
            @Override
            public void configure() {

                this.from("direct:start").multicast(new MulticastAggregation())
                        .parallelProcessing(true)
                        .parallelAggregate()
                        .streaming()
                        .to("direct:proc1", "direct:proc2")
//                        .aggregate(simple("${body}"), new MulticastAggregation())
//                        //.eagerCheckCompletion()
//                        .completionPredicate(new Predicate() {
//                            @Override
//                            public boolean matches(final Exchange exchange) {
//                                if(exchange.getProperty("AGG")!=null) {
//                                    LOGGER.debug("completionPredicate returning false");
//                                    return true;
//                                }
//                                LOGGER.debug("completionPredicate returning false");
//                                return false;
//                            }
//                        })
                       .bean(FinalProc.class)
                        .log("Completed");

                this.from("direct:proc1").process(new Proc1());
                this.from("direct:proc2")
                        .process(new Proc2());

            }
        };
    }

    private static class MulticastAggregation implements AggregationStrategy , Predicate {

        static String value = ":";

        @Override
        public Exchange aggregate(final Exchange oldExchange, final Exchange newExchange) {

            LOGGER.debug("AGGREGATE ....");
            if (oldExchange == null) {
                LOGGER.debug(" AGGREGATE old exchange is null");
                return newExchange;
            }
            LOGGER.debug("AGGREGATE OLD Exchange not null");
            return oldExchange;
        }

        @Override public boolean matches(final Exchange exchange) {
            if(exchange.getProperty("AGG")!=null){
                LOGGER.debug("Predicate  false");
                return true;
            }
            LOGGER.debug("Predicate true");
            return false;
        }
    }
}