protected Splitter createSplitterInstance(Expression expression, Processor processor) { return new Splitter(expression, processor); }
/** * Processes the given exchange * This method is the entry point for splitting the given exchange into * its parts via the split rule. Subclasses can change the created sub * exchanges by overriding {@link #finalizeSubExchange(Exchange, Exchange, SplitIndex)} * and the aggregate result by overriding {@link #finalizeAggregate(Exchange, Exchange)}. * * @param origExchange exchange that should be split by this processor */ @Override protected void processNext(Exchange origExchange) throws Exception { notNull(origExchange, "origExchange"); Iterable splitResult = evaluateSplitRule(origExchange); Exchange aggregate = processAllResults(origExchange, splitResult); finalizeAggregate(origExchange, aggregate); }
private Exchange processResult(final Exchange origExchange, final SplitIndex index, final Object splitPart) throws Exception { final Exchange subExchange = origExchange.copy(); Message message = subExchange.getIn(); message.setBody(splitPart); finalizeSubExchange(origExchange, subExchange, index); super.processNext(subExchange); return subExchange; }
private Exchange processAllResults(Exchange origExchange, Iterable splitResult) throws Exception { Exchange aggregate = null; Iterator iterator = splitResult.iterator(); int counter = 0; while (iterator.hasNext()) { Object splitPart = iterator.next(); SplitIndex idx = SplitIndex.valueOf(counter, !iterator.hasNext()); Exchange subExchange = processResult(origExchange, idx, splitPart); aggregate = doAggregate(aggregate, subExchange); ++counter; } return aggregate; }
@Test public void testSplitRuleWithArrayResult() throws Exception { Exchange origExchange = createTestExchange(); origExchange.getIn().setBody("bla,blu"); Splitter splitterWithArrayResult = new Splitter(new Expression() { @Override public <T> T evaluate(Exchange exchange, Class<T> type) { return type.cast(getContent(exchange).split(",")); }}, dest); splitterWithArrayResult.aggregate(new TestAggregationStrategy()); splitterWithArrayResult.process(origExchange); List<Exchange> received = dest.getReceived(); assertEquals(2, received.size()); assertEquals("bla", getContent(received.get(0))); assertEquals("blu", getContent(received.get(1))); assertEquals("bla:blu", origExchange.getOut().getBody()); }
@Test public void testSplitRuleResultsInNothing() throws Exception { Splitter splitterEmptyRule = new Splitter(new Expression() { @Override public <T> T evaluate(Exchange exchange, Class<T> type) { return null; }}, dest); Exchange origExchange = createTestExchange(); origExchange.getIn().setBody("bla,blu"); splitterEmptyRule.process(origExchange); List<Exchange> received = dest.getReceived(); assertEquals(0, received.size()); }
@Test public void testResetToDefaults() throws Exception { splitter.aggregate(null); Exchange origExchange = createTestExchange(); origExchange.getIn().setBody("bla,blu"); splitter.process(origExchange); List<Exchange> received = dest.getReceived(); assertEquals(2, received.size()); assertEquals("bla", getContent(received.get(0))); assertEquals("blu", getContent(received.get(1))); assertEquals("blu", origExchange.getOut().getBody()); }
@Override protected void finalizeAggregate(Exchange origExchange, Exchange aggregate) { ManagedMessage origMessage = new PlatformMessage(origExchange); SplitHistory origHistory = origMessage.getSplitHistory(); // The aggregate needs to be copied to ensure that we can change it // without affecting the input into the destination processor of the // splitter. if (aggregate != null){ Exchange copiedAggregate = aggregate.copy(); ManagedMessage message = new PlatformMessage(copiedAggregate); SplitHistory aggregateHistory = message.getSplitHistory(); if (!aggregateHistory.equals(origHistory)) { message.setSplitHistory(origHistory); } super.finalizeAggregate(origExchange, copiedAggregate); } else { super.finalizeAggregate(origExchange, aggregate); } }
@Override public Processor createProcessor(RouteContext routeContext) throws Exception { Processor childProcessor = createChildProcessor(routeContext, false); if (aggregationStrategy == null) { aggregationStrategy = new UseLatestAggregationStrategy(); } if (expressionBean != null) { expressionDefinition = new ExpressionDefinition(routeContext.lookup(expressionBean, Expression.class)); } Expression expression = expressionDefinition.createExpression(routeContext); Splitter splitter = createSplitterInstance(expression, childProcessor); splitter.aggregate(aggregationStrategy); return splitter; }
@Test public void testProcess() throws Exception { Exchange origExchange = createTestExchange(); origExchange.getIn().setBody("bla,blu"); splitter.process(origExchange); List<Exchange> received = dest.getReceived(); assertEquals(2, received.size()); assertEquals("bla", getContent(received.get(0))); assertEquals("blu", getContent(received.get(1))); assertEquals("bla:blu", origExchange.getOut().getBody()); }
@Test public void testSplitRuleWithNonIterableResult() throws Exception { Splitter splitterSimpleRule = new Splitter(new Expression() { @Override public <T> T evaluate(Exchange exchange, Class<T> type) { return type.cast("smurf:" + exchange.getIn().getBody()); }}, dest); Exchange origExchange = createTestExchange(); origExchange.getIn().setBody("bla,blu"); splitterSimpleRule.process(origExchange); List<Exchange> received = dest.getReceived(); assertEquals(1, received.size()); assertEquals("smurf:bla,blu", getContent(received.get(0))); }
@Test public void testSplitRuleResultsInIterator() throws Exception { final List<String> results = Arrays.asList("bla", "blu"); Splitter splitterIteratorRule = new Splitter(new Expression() { @Override public <T> T evaluate(Exchange exchange, Class<T> type) { return type.cast(results.iterator()); }}, dest); Exchange origExchange = createTestExchange(); origExchange.getIn().setBody("bla,blu"); splitterIteratorRule.process(origExchange); List<Exchange> received = dest.getReceived(); assertEquals(2, received.size()); assertEquals("bla", getContent(received.get(0))); assertEquals("blu", getContent(received.get(1))); assertEquals("blu", origExchange.getOut().getBody()); }
@Override protected void finalizeSubExchange(Exchange origExchange, Exchange subExchange, SplitIndex index) { super.finalizeSubExchange(origExchange, subExchange, index); if (splitOnlyHasSingleResult(index)) { return; } ManagedMessage origMessage = new PlatformMessage(origExchange); SplitHistory origHistory = origMessage.getSplitHistory(); SplitHistory subHistory = origHistory.split(index.getIndex(), index.isLast()); ManagedMessage subMessage = new PlatformMessage(subExchange); subMessage.setSplitHistory(subHistory); }
@Test(expected=IllegalArgumentException.class) public void testForNullSafeConstructor() { splitter = new Splitter(null, dest); }