public void write(List<? extends T> items) throws Exception { // Block until expecting <= throttle limit while (localState.getExpecting() > throttleLimit) { getNextResult(); } if (!items.isEmpty()) { ChunkRequest<T> request = localState.getRequest(items); if (logger.isDebugEnabled()) { logger.debug("Dispatching chunk: " + request); } messagingGateway.send(new GenericMessage<>(request)); localState.incrementExpected(); } }
protected void setupMessagingTemplate() { PollableChannel pollableChannel = this.appCtx.getBean("target", PollableChannel.class); this.messagingTemplate = new MessagingTemplate(); this.messagingTemplate.setDefaultDestination(pollableChannel); this.messagingTemplate.setReceiveTimeout(10000); }
private List<String> sendAndReceiveMessage(DirectChannel channel, int timeout, Message<?> input) { MessagingTemplate messagingTemplate = new MessagingTemplate(); messagingTemplate.setReceiveTimeout(timeout); @SuppressWarnings("unchecked") Message<List<String>> message = (Message<List<String>>) messagingTemplate.sendAndReceive(channel, input); return message == null ? null : message.getPayload(); }
/** * Build a master {@link TaskletStep}. * * @return the configured master step * @see RemoteChunkHandlerFactoryBean */ public TaskletStep build() { Assert.notNull(this.inputChannel, "An InputChannel must be provided"); Assert.state(this.outputChannel == null || this.messagingTemplate == null, "You must specify either an outputChannel or a messagingTemplate but not both."); // configure messaging template if (this.messagingTemplate == null) { this.messagingTemplate = new MessagingTemplate(); this.messagingTemplate.setDefaultChannel(this.outputChannel); if (this.logger.isDebugEnabled()) { this.logger.debug("No messagingTemplate was provided, using a default one"); } } // configure item writer ChunkMessageChannelItemWriter<O> chunkMessageChannelItemWriter = new ChunkMessageChannelItemWriter<>(); chunkMessageChannelItemWriter.setMessagingOperations(this.messagingTemplate); chunkMessageChannelItemWriter.setMaxWaitTimeouts(this.maxWaitTimeouts); chunkMessageChannelItemWriter.setThrottleLimit(this.throttleLimit); chunkMessageChannelItemWriter.setReplyChannel(this.inputChannel); super.writer(chunkMessageChannelItemWriter); return super.build(); }
/** * If errorOnTimeout is true, construct an instance that will send an * {@link ErrorMessage} with a {@link MessageTimeoutException} payload to the error * channel if a reply is expected but none is received. If no error channel is * configured, the {@link MessageTimeoutException} will be thrown. * * @param errorOnTimeout true to create the error message. * @since 4.2 */ public MessagingGatewaySupport(boolean errorOnTimeout) { MessagingTemplate template = new MessagingTemplate(); template.setMessageConverter(this.messageConverter); template.setSendTimeout(DEFAULT_TIMEOUT); template.setReceiveTimeout(this.replyTimeout); this.messagingTemplate = template; this.errorOnTimeout = errorOnTimeout; }
@Before public void setUp() { jobRepository = new SimpleJobRepository(new MapJobInstanceDao(), new MapJobExecutionDao(), new MapStepExecutionDao(), new MapExecutionContextDao()); factory.setJobRepository(jobRepository); factory.setTransactionManager(new ResourcelessTransactionManager()); factory.setBeanName("step"); factory.setItemWriter(writer); factory.setCommitInterval(4); MessagingTemplate gateway = new MessagingTemplate(); writer.setMessagingOperations(gateway); gateway.setDefaultChannel(requests); writer.setReplyChannel(replies); gateway.setReceiveTimeout(100); TestItemWriter.count = 0; // Drain queues Message<?> message = replies.receive(10); while (message != null) { System.err.println(message); message = replies.receive(10); } }
@Test public void literalValue() { MessagingTemplate template = new MessagingTemplate(); template.setDefaultDestination(literalValueInput); Message<?> result = template.sendAndReceive(new GenericMessage<>("foo")); Map<String, Object> headers = result.getHeaders(); assertEquals("http://test", headers.get(WebServiceHeaders.SOAP_ACTION)); }
@Test public void expressionWithDateType() { MessagingTemplate template = new MessagingTemplate(); MessageChannel channel = context.getBean("expressionWithDateTypeInput", MessageChannel.class); Message<?> result = template.sendAndReceive(channel, new GenericMessage<>("test")); assertNotNull(result); Object headerValue = result.getHeaders().get("currentDate"); assertEquals(Date.class, headerValue.getClass()); Date date = (Date) headerValue; assertTrue(new Date().getTime() - date.getTime() < 1000); }
@Test @SuppressWarnings("unchecked") public void testGetRecipients() { MessagingTemplate messagingTemplate = new MessagingTemplate(); messagingTemplate.setReceiveTimeout(1000); messagingTemplate.convertAndSend(input, "@'simpleRouter.handler'.addRecipient('channel1')"); messagingTemplate.convertAndSend(input, "@'simpleRouter.handler'.getRecipients()"); PollableChannel channel1 = (PollableChannel) context.getBean("channel1"); Message<?> result = this.output.receive(0); Collection<Recipient> mappings = (Collection<Recipient>) result.getPayload(); assertEquals(channel1, mappings.iterator().next().getChannel()); }
private MessageHandler echoInboundStringHandler() { return message -> { assertTrue(message.getPayload() instanceof String); MessagingTemplate template = new MessagingTemplate(); template.setDefaultDestination((MessageChannel) message.getHeaders().getReplyChannel()); template.send(message); }; }
@Test public void testJmx() throws Exception { MessagingTemplate messagingTemplate = new MessagingTemplate(); messagingTemplate.setReceiveTimeout(1000); Set<ObjectName> names = this.server.queryNames(ObjectName .getInstance("update.mapping.domain:type=MessageHandler,name=router,bean=endpoint"), null); assertEquals(1, names.size()); Map<String, String> map = new HashMap<String, String>(); map.put("foo", "bar"); map.put("baz", "qux"); Object[] params = new Object[] {map}; this.server.invoke(names.iterator().next(), "setChannelMappings", params, new String[] { "java.util.Map" }); Map<?, ?> mappings = messagingTemplate.convertSendAndReceive(control, "@'router.handler'.getChannelMappings()", Map.class); assertNotNull(mappings); assertEquals(2, mappings.size()); assertEquals("bar", mappings.get("foo")); assertEquals("qux", mappings.get("baz")); }
@Test public void testControlMessageToChannelMetrics() { MessageChannel control = this.context.getBean("controlChannel", MessageChannel.class); MessagingTemplate messagingTemplate = new MessagingTemplate(); Object value = messagingTemplate.convertSendAndReceive(control, "@integrationMbeanExporter.getChannelSendRate('testChannel').count", Object.class); assertEquals(0, value); }
this.messagingTemplate.send((MessageChannel) replyChannel, (Message<?>) output); this.messagingTemplate.convertAndSend((MessageChannel) replyChannel, output); this.messagingTemplate.send((String) replyChannel, (Message<?>) output); this.messagingTemplate.convertAndSend((String) replyChannel, output);
@Test public void testChangeRouterMappings() { MessagingTemplate messagingTemplate = new MessagingTemplate(); messagingTemplate.setReceiveTimeout(1000); messagingTemplate.convertAndSend(control, "@'router.handler'.replaceChannelMappings('foo=bar \n baz=qux')"); Map<?, ?> mappings = messagingTemplate.convertSendAndReceive(control, "@'router.handler'.getChannelMappings()", Map.class); assertNotNull(mappings); assertEquals(2, mappings.size()); assertEquals("bar", mappings.get("foo")); assertEquals("qux", mappings.get("baz")); messagingTemplate.convertAndSend(control, "@'router.handler'.replaceChannelMappings('foo=qux \n baz=bar')"); mappings = messagingTemplate.convertSendAndReceive(control, "@'router.handler'.getChannelMappings()", Map.class); assertEquals(2, mappings.size()); assertEquals("bar", mappings.get("baz")); assertEquals("qux", mappings.get("foo")); }
@Test public void to() throws InterruptedException { MessagingTemplate messagingTemplate = new MessagingTemplate(); CountDownLatch callLatch = new CountDownLatch(1); MessageHandler handler = mock(MessageHandler.class); willAnswer(invocation -> { Message<?> message = invocation.getArgument(0); String chatToUser = (String) message.getHeaders().get(XmppHeaders.TO); assertNotNull(chatToUser); assertEquals("test1@example.org", chatToUser); callLatch.countDown(); return null; }) .given(handler) .handleMessage(Mockito.any(Message.class)); this.output.subscribe(handler); messagingTemplate.send(this.input, MessageBuilder.withPayload("foo").build()); assertTrue(callLatch.await(10, TimeUnit.SECONDS)); verify(handler, times(1)).handleMessage(Mockito.any(Message.class)); }
messagingTemplate.setReceiveTimeout(10000); assertEquals("Hello, FOO", messagingTemplate.convertSendAndReceive("foo", String.class)); assertEquals("Hello, BAR", messagingTemplate.convertSendAndReceive("bar", String.class)); messagingTemplate.receive(); fail("UnsupportedOperationException expected");
private Object sendAndReceive(MessageChannel channel, Object payload) { MessagingTemplate template = new MessagingTemplate(); template.setDefaultDestination(channel); return template.convertSendAndReceive(payload, Object.class); }
public static void main(String[] args) { ApplicationContext context = new ClassPathXmlApplicationContext("siia/jms/channel-adapters.xml"); MessageChannel toJMS = context.getBean("toJMS", MessageChannel.class); PollableChannel fromJMS = context.getBean("fromJMS", PollableChannel.class); MessagingTemplate template = new MessagingTemplate(); template.convertAndSend(toJMS, "echo"); Object response = template.receiveAndConvert(fromJMS); System.out.println("response: " + response); }
@Test public void test() { Message<?> received = fooChannel.receive(10000); assertNotNull(received); Collection<?> primes = (Collection<?>) received.getPayload(); assertThat(primes, Matchers.<Object>contains(2, 3, 5, 7)); received = fooChannel.receive(100); // verify maxMessagesPerPoll == 1 assertNull(received); MessagingTemplate template = new MessagingTemplate(this.control); template.convertAndSend("@'storedProcJavaConfigTests.Config.storedProc.inboundChannelAdapter'.stop()"); assertFalse(template.convertSendAndReceive( "@'storedProcJavaConfigTests.Config.storedProc.inboundChannelAdapter'.isRunning()", Boolean.class)); }
@Test public void testSimpleInboundChannelAdapterWithUpdate() { setUp("pollingForMapJdbcInboundChannelAdapterWithUpdateTest.xml", getClass()); this.jdbcTemplate.update("insert into item values(1,'',2)"); Message<?> message = messagingTemplate.receive(); assertNotNull(message); messagingTemplate.setReceiveTimeout(1); message = messagingTemplate.receive(); assertNull(message); }