protected AbstractMessageSplitter createMethodInvokingSplitter(Object targetObject, String targetMethodName) { return (StringUtils.hasText(targetMethodName)) ? new MethodInvokingSplitter(targetObject, targetMethodName) : new MethodInvokingSplitter(targetObject); }
@Override protected void doInit() { super.doInit(); if (this.iterator && this.jaxpExpression == null) { logger.info("The 'iterator' option isn't available for an external XPathExpression. Will be ignored"); this.iterator = false; } }
/** * Set delimiters to tokenize String values. The default is * <code>null</code> indicating that no tokenizing should occur. * If delimiters are provided, they will be applied to any String payload. * Only applied if provided {@code splitter} is instance of {@link DefaultMessageSplitter}. * @param delimiters The delimiters. * @return the endpoint spec. * @see DefaultMessageSplitter#setDelimiters(String) */ public SplitterEndpointSpec<S> delimiters(String delimiters) { if (this.handler instanceof DefaultMessageSplitter) { ((DefaultMessageSplitter) this.handler).setDelimiters(delimiters); } else { logger.warn("'delimiters' can be applied only for the DefaultMessageSplitter"); } return this; }
@Bean @Splitter(inputChannel = "splitterChannel") public MessageHandler splitter() { DefaultMessageSplitter defaultMessageSplitter = new DefaultMessageSplitter(); defaultMessageSplitter.setOutputChannelName("serviceChannel"); return defaultMessageSplitter; }
@Override protected MessageHandler createDefaultHandler() { return configureSplitter(new DefaultMessageSplitter()); }
@Test public void splitToIterator_allMessagesSent() { int messageQuantity = 5; MethodInvokingSplitter splitter = new MethodInvokingSplitter(new IteratorTestBean(messageQuantity)); splitter.setBeanFactory(mock(BeanFactory.class)); QueueChannel replyChannel = new QueueChannel(); splitter.setOutputChannel(replyChannel); splitter.afterPropertiesSet(); splitter.handleMessage(this.message); assertThat(replyChannel.getQueueSize(), is(messageQuantity)); }
@Test public void splitToIterable_allMessagesSent() { int messageQuantity = 5; MethodInvokingSplitter splitter = new MethodInvokingSplitter(new IterableTestBean(messageQuantity)); splitter.setBeanFactory(mock(BeanFactory.class)); QueueChannel replyChannel = new QueueChannel(); splitter.setOutputChannel(replyChannel); splitter.afterPropertiesSet(); splitter.handleMessage(this.message); assertThat(replyChannel.getQueueSize(), is(messageQuantity)); }
@Override protected void postProcessReplyProducer(AbstractMessageProducingHandler handler) { super.postProcessReplyProducer(handler); if (!(handler instanceof AbstractMessageSplitter)) { Assert.isNull(this.applySequence, "Cannot set applySequence if the referenced bean is " + "an AbstractReplyProducingMessageHandler, but not an AbstractMessageSplitter"); Assert.isNull(this.delimiters, "Cannot set delimiters if the referenced bean is not an " + "an AbstractReplyProducingMessageHandler, but not an AbstractMessageSplitter"); } else { AbstractMessageSplitter splitter = (AbstractMessageSplitter) handler; if (this.delimiters != null) { Assert.isInstanceOf(DefaultMessageSplitter.class, splitter, "The 'delimiters' property is only available for a Splitter definition where no 'ref', " + "'expression', or inner bean has been provided."); ((DefaultMessageSplitter) splitter).setDelimiters(this.delimiters); } if (this.applySequence != null) { splitter.setApplySequence(this.applySequence); } } }
@Test(expected = IllegalArgumentException.class) public void multiplePublicMethods() { new MethodInvokingSplitter(new MultiplePublicMethodTestBean()); }
@Test(expected = IllegalArgumentException.class) public void ambiguousTypeMatch() { new MethodInvokingSplitter(new AmbiguousTypeMatchTestBean()); }
@Override protected MessageHandler createExpressionEvaluatingHandler(Expression expression) { return configureSplitter(new ExpressionEvaluatingSplitter(expression)); }
/** * Set the applySequence flag to the specified value. Defaults to {@code true}. * @param applySequence the applySequence. * @return the endpoint spec. * @see AbstractMessageSplitter#setApplySequence(boolean) */ public SplitterEndpointSpec<S> applySequence(boolean applySequence) { this.handler.setApplySequence(applySequence); return _this(); }
@Override protected void doInit() { ConversionService conversionService = getConversionService(); if (conversionService != null && this.messageProcessor instanceof AbstractMessageProcessor) { ((AbstractMessageProcessor<?>) this.messageProcessor).setConversionService(conversionService); } if (this.messageProcessor instanceof BeanFactoryAware && this.getBeanFactory() != null) { ((BeanFactoryAware) this.messageProcessor).setBeanFactory(this.getBeanFactory()); } }
@SuppressWarnings({"unchecked", "rawtypes"}) public ExpressionEvaluatingSplitter(Expression expression) { super(new ExpressionEvaluatingMessageProcessor(expression)); setPrimaryExpression(expression); }
@Test public void channelResolver_isNotNull() throws Exception { splitter.setOutputChannel(null); Message<String> message = MessageBuilder.withPayload("fooBar") .setReplyChannelName("out").build(); inMethodInvoking.send(message); }
public Message<String>[] stringToMessageArray(String input) { String[] strings = input.split("\\."); Message<String>[] messages = new TestStringMessage[strings.length]; for (int i = 0; i < strings.length; i++) { messages[i] = new TestStringMessage(strings[i]); } return messages; }
@Bean @Splitter(inputChannel = "splitChannel") public MessageHandler splitter() { DefaultMessageSplitter splitter = new DefaultMessageSplitter(); splitter.setOutputChannelName("toJmsChannel"); return splitter; }
/** * Populate the {@link DefaultMessageSplitter} with provided options * to the current integration flow position. * Typically used with a Java 8 Lambda expression: * <pre class="code"> * {@code * .split(s -> s.applySequence(false).delimiters(",")) * } * </pre> * @param endpointConfigurer the {@link Consumer} to provide integration endpoint options * and for {@link DefaultMessageSplitter}. * @return the current {@link IntegrationFlowDefinition}. * @see SplitterEndpointSpec */ public B split(Consumer<SplitterEndpointSpec<DefaultMessageSplitter>> endpointConfigurer) { return split(new DefaultMessageSplitter(), endpointConfigurer); }
public Message<String>[] messageToMessageArray(Message<?> input) { String[] strings = input.getPayload().toString().split("\\."); Message<String>[] messages = new TestStringMessage[strings.length]; for (int i = 0; i < strings.length; i++) { messages[i] = new TestStringMessage(strings[i]); } return messages; }
@Bean @Splitter(inputChannel = "splitterChannel", applySequence = "false") public MessageHandler splitter() { return new DefaultMessageSplitter(); }