Example usage for org.springframework.integration.support MessageBuilder withPayload

List of usage examples for org.springframework.integration.support MessageBuilder withPayload

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.integration.support.*
  5. MessageBuilder
  6. withPayload

Introduction

In this page you can find the example usage for org.springframework.integration.support MessageBuilder withPayload.

Prototype

public static <T> MessageBuilder<T> withPayload(T payload)

Source Link

Document

Create a builder for a new Message instance with the provided payload.

Usage

From source file:org.springframework.integration.config.xml.GatewayParserTests.java

private void startResponder(final PollableChannel requestChannel, final MessageChannel replyChannel) {
    Executors.newSingleThreadExecutor().execute(() -> {
        Message<?> request = requestChannel.receive(60000);
        assertNotNull("Request not received", request);
        Message<?> reply = MessageBuilder.fromMessage(request).setCorrelationId(request.getHeaders().getId())
                .build();//  ww  w.j  ava2  s. co  m
        Object payload = null;
        if (request.getPayload().equals("futureSync")) {
            payload = new AsyncResult<Message<?>>(reply);
        } else if (request.getPayload().equals("flowCompletable")) {
            payload = CompletableFuture.<String>completedFuture("SYNC_COMPLETABLE");
        } else if (request.getPayload().equals("flowCustomCompletable")) {
            MyCompletableFuture myCompletableFuture1 = new MyCompletableFuture();
            myCompletableFuture1.complete("SYNC_CUSTOM_COMPLETABLE");
            payload = myCompletableFuture1;
        } else if (request.getPayload().equals("flowCompletableM")) {
            payload = CompletableFuture.<Message<?>>completedFuture(reply);
        } else if (request.getPayload().equals("flowCustomCompletableM")) {
            MyCompletableMessageFuture myCompletableFuture2 = new MyCompletableMessageFuture();
            myCompletableFuture2.complete(reply);
            payload = myCompletableFuture2;
        }
        if (payload != null) {
            reply = MessageBuilder.withPayload(payload).copyHeaders(reply.getHeaders()).build();
        }
        replyChannel.send(reply);
    });
}

From source file:org.springframework.integration.configuration.EnableIntegrationTests.java

@Test
public void testAnnotatedServiceActivator() throws Exception {
    this.serviceActivatorEndpoint.setReceiveTimeout(10000);
    this.serviceActivatorEndpoint.start();
    assertTrue(this.inputReceiveLatch.await(10, TimeUnit.SECONDS));

    assertEquals(10L, TestUtils.getPropertyValue(this.serviceActivatorEndpoint, "maxMessagesPerPoll"));

    Trigger trigger = TestUtils.getPropertyValue(this.serviceActivatorEndpoint, "trigger", Trigger.class);
    assertThat(trigger, Matchers.instanceOf(PeriodicTrigger.class));
    assertEquals(100L, TestUtils.getPropertyValue(trigger, "period"));
    assertFalse(TestUtils.getPropertyValue(trigger, "fixedRate", Boolean.class));

    assertTrue(this.annotationTestService.isRunning());
    Log logger = spy(TestUtils.getPropertyValue(this.serviceActivatorEndpoint, "logger", Log.class));
    when(logger.isDebugEnabled()).thenReturn(true);
    final CountDownLatch pollerInterruptedLatch = new CountDownLatch(1);
    doAnswer(invocation -> {//from  ww w  . j  av  a 2  s .  c o  m
        pollerInterruptedLatch.countDown();
        invocation.callRealMethod();
        return null;
    }).when(logger).debug("Received no Message during the poll, returning 'false'");
    new DirectFieldAccessor(this.serviceActivatorEndpoint).setPropertyValue("logger", logger);

    this.serviceActivatorEndpoint.stop();
    assertFalse(this.annotationTestService.isRunning());

    // wait until the service activator's poller is interrupted.
    assertTrue(pollerInterruptedLatch.await(10, TimeUnit.SECONDS));
    this.serviceActivatorEndpoint.start();
    assertTrue(this.annotationTestService.isRunning());

    trigger = TestUtils.getPropertyValue(this.serviceActivatorEndpoint1, "trigger", Trigger.class);
    assertThat(trigger, Matchers.instanceOf(PeriodicTrigger.class));
    assertEquals(100L, TestUtils.getPropertyValue(trigger, "period"));
    assertTrue(TestUtils.getPropertyValue(trigger, "fixedRate", Boolean.class));

    trigger = TestUtils.getPropertyValue(this.serviceActivatorEndpoint2, "trigger", Trigger.class);
    assertThat(trigger, Matchers.instanceOf(CronTrigger.class));
    assertEquals("0 5 7 * * *", TestUtils.getPropertyValue(trigger, "sequenceGenerator.expression"));

    trigger = TestUtils.getPropertyValue(this.serviceActivatorEndpoint3, "trigger", Trigger.class);
    assertThat(trigger, Matchers.instanceOf(PeriodicTrigger.class));
    assertEquals(11L, TestUtils.getPropertyValue(trigger, "period"));
    assertFalse(TestUtils.getPropertyValue(trigger, "fixedRate", Boolean.class));

    trigger = TestUtils.getPropertyValue(this.serviceActivatorEndpoint4, "trigger", Trigger.class);
    assertThat(trigger, Matchers.instanceOf(PeriodicTrigger.class));
    assertEquals(1000L, TestUtils.getPropertyValue(trigger, "period"));
    assertFalse(TestUtils.getPropertyValue(trigger, "fixedRate", Boolean.class));
    assertSame(this.myTrigger, trigger);

    trigger = TestUtils.getPropertyValue(this.transformer, "trigger", Trigger.class);
    assertThat(trigger, Matchers.instanceOf(PeriodicTrigger.class));
    assertEquals(10L, TestUtils.getPropertyValue(trigger, "period"));
    assertFalse(TestUtils.getPropertyValue(trigger, "fixedRate", Boolean.class));

    this.input.send(MessageBuilder.withPayload("Foo").build());

    Message<?> interceptedMessage = this.wireTapChannel.receive(10000);
    assertNotNull(interceptedMessage);
    assertEquals("Foo", interceptedMessage.getPayload());

    Message<?> receive = this.output.receive(10000);
    assertNotNull(receive);
    assertEquals("FOO", receive.getPayload());

    receive = this.wireTapFromOutput.receive(10000);
    assertNotNull(receive);
    assertEquals("FOO", receive.getPayload());

    MessageHistory messageHistory = receive.getHeaders().get(MessageHistory.HEADER_NAME, MessageHistory.class);
    assertNotNull(messageHistory);
    String messageHistoryString = messageHistory.toString();
    assertThat(messageHistoryString, Matchers.containsString("input"));
    assertThat(messageHistoryString,
            Matchers.containsString("annotationTestService.handle.serviceActivator.handler"));
    assertThat(messageHistoryString, Matchers.not(Matchers.containsString("output")));

    receive = this.publishedChannel.receive(10000);

    assertNotNull(receive);
    assertEquals("foo", receive.getPayload());

    messageHistory = receive.getHeaders().get(MessageHistory.HEADER_NAME, MessageHistory.class);
    assertNotNull(messageHistory);
    messageHistoryString = messageHistory.toString();
    assertThat(messageHistoryString, Matchers.not(Matchers.containsString("input")));
    assertThat(messageHistoryString, Matchers.not(Matchers.containsString("output")));
    assertThat(messageHistoryString, Matchers.containsString("publishedChannel"));

    assertNull(this.wireTapChannel.receive(0));
    assertThat(this.testChannelInterceptor.getInvoked(), Matchers.greaterThan(0));
    assertThat(this.fbInterceptorCounter.get(), Matchers.greaterThan(0));

    assertTrue(this.context.containsBean("annotationTestService.count.inboundChannelAdapter.source"));
    Object messageSource = this.context.getBean("annotationTestService.count.inboundChannelAdapter.source");
    assertThat(messageSource, Matchers.instanceOf(MethodInvokingMessageSource.class));

    assertNull(this.counterChannel.receive(10));

    SmartLifecycle countSA = this.context.getBean("annotationTestService.count.inboundChannelAdapter",
            SmartLifecycle.class);
    assertFalse(countSA.isAutoStartup());
    assertEquals(23, countSA.getPhase());
    countSA.start();

    for (int i = 0; i < 10; i++) {
        Message<?> message = this.counterChannel.receive(1000);
        assertNotNull(message);
        assertEquals(i + 1, message.getPayload());
    }

    Message<?> message = this.fooChannel.receive(1000);
    assertNotNull(message);
    assertEquals("foo", message.getPayload());
    message = this.fooChannel.receive(1000);
    assertNotNull(message);
    assertEquals("foo", message.getPayload());
    assertNull(this.fooChannel.receive(10));

    message = this.messageChannel.receive(1000);
    assertNotNull(message);
    assertEquals("bar", message.getPayload());
    assertTrue(message.getHeaders().containsKey("foo"));
    assertEquals("FOO", message.getHeaders().get("foo"));

    MessagingTemplate messagingTemplate = new MessagingTemplate(this.controlBusChannel);
    assertFalse(messagingTemplate.convertSendAndReceive("@lifecycle.isRunning()", Boolean.class));
    this.controlBusChannel.send(new GenericMessage<String>("@lifecycle.start()"));
    assertTrue(messagingTemplate.convertSendAndReceive("@lifecycle.isRunning()", Boolean.class));
    this.controlBusChannel.send(new GenericMessage<String>("@lifecycle.stop()"));
    assertFalse(messagingTemplate.convertSendAndReceive("@lifecycle.isRunning()", Boolean.class));
}

From source file:org.springframework.integration.dsl.test.ftp.FtpTests.java

@Test
public void testFtpOutboundFlow() {
    String fileName = "foo.file";
    this.toFtpChannel.send(MessageBuilder.withPayload("foo").setHeader(FileHeaders.FILENAME, fileName).build());

    RemoteFileTemplate<FTPFile> template = new RemoteFileTemplate<>(this.ftpSessionFactory);
    FTPFile[] files = template.execute(//from  w  w  w.j a  v  a2s.co m
            session -> session.list(this.ftpServer.getTargetFtpDirectory().getName() + "/" + fileName));
    assertEquals(1, files.length);
    assertEquals(3, files[0].getSize());
}

From source file:org.springframework.integration.dsl.test.IntegrationFlowTests.java

@Test
public void testDirectFlow() {
    assertTrue(this.beanFactory.containsBean("filter"));
    assertTrue(this.beanFactory.containsBean("filter.handler"));
    QueueChannel replyChannel = new QueueChannel();
    Message<String> message = MessageBuilder.withPayload("100").setReplyChannel(replyChannel).build();
    try {/*from  w w  w  .j  ava  2s  .  c  om*/
        this.inputChannel.send(message);
        fail("Expected MessageDispatchingException");
    } catch (Exception e) {
        assertThat(e, instanceOf(MessageDeliveryException.class));
        assertThat(e.getCause(), instanceOf(MessageDispatchingException.class));
        assertThat(e.getMessage(), containsString("Dispatcher has no subscribers"));
    }
    this.controlBus.send("@payloadSerializingTransformer.start()");

    final AtomicBoolean used = new AtomicBoolean();

    this.foo.subscribe(m -> used.set(true));

    this.inputChannel.send(message);
    Message<?> reply = replyChannel.receive(5000);
    assertNotNull(reply);
    assertEquals(200, reply.getPayload());

    Message<?> successMessage = this.successChannel.receive(5000);
    assertNotNull(successMessage);
    assertEquals(100, successMessage.getPayload());

    assertTrue(used.get());
}

From source file:org.springframework.integration.dsl.test.IntegrationFlowTests.java

@Test
public void testFileHandler() throws Exception {
    Message<?> message = MessageBuilder.withPayload("foo").setHeader(FileHeaders.FILENAME, "foo").build();
    try {//w  w  w  . j a va 2 s . c o m
        this.fileFlow1Input.send(message);
        fail("NullPointerException expected");
    } catch (Exception e) {
        assertThat(e, instanceOf(MessageHandlingException.class));
        assertThat(e.getCause(), instanceOf(NullPointerException.class));
    }
    DefaultFileNameGenerator fileNameGenerator = new DefaultFileNameGenerator();
    fileNameGenerator.setBeanFactory(this.beanFactory);
    Object targetFileWritingMessageHandler = this.fileWritingMessageHandler;
    if (this.fileWritingMessageHandler instanceof Advised) {
        TargetSource targetSource = ((Advised) this.fileWritingMessageHandler).getTargetSource();
        if (targetSource != null) {
            targetFileWritingMessageHandler = targetSource.getTarget();
        }
    }
    DirectFieldAccessor dfa = new DirectFieldAccessor(targetFileWritingMessageHandler);
    dfa.setPropertyValue("fileNameGenerator", fileNameGenerator);
    this.fileFlow1Input.send(message);

    assertTrue(new java.io.File(tmpDir, "foo").exists());
}

From source file:org.springframework.integration.dsl.test.IntegrationFlowTests.java

@Test
public void testMethodInvokingMessageHandler() {
    QueueChannel replyChannel = new QueueChannel();
    Message<?> message = MessageBuilder.withPayload("world")
            .setHeader(MessageHeaders.REPLY_CHANNEL, replyChannel).build();
    this.methodInvokingInput.send(message);
    Message<?> receive = replyChannel.receive(5000);
    assertNotNull(receive);//w w  w  .j  ava 2s .  c o  m
    assertEquals("Hello World and world", receive.getPayload());
}

From source file:org.springframework.integration.dsl.test.IntegrationFlowTests.java

@Test
public void testLambdas() {
    QueueChannel replyChannel = new QueueChannel();
    Message<?> message = MessageBuilder.withPayload("World")
            .setHeader(MessageHeaders.REPLY_CHANNEL, replyChannel).build();
    this.lamdasInput.send(message);
    Message<?> receive = replyChannel.receive(5000);
    assertNotNull(receive);//from   w ww  .  ja  v  a 2  s  .co  m
    assertEquals("Hello World", receive.getPayload());

    message = MessageBuilder.withPayload("Spring").setHeader(MessageHeaders.REPLY_CHANNEL, replyChannel)
            .build();

    this.lamdasInput.send(message);
    assertNull(replyChannel.receive(10));

}

From source file:org.springframework.integration.dsl.test.IntegrationFlowTests.java

@Test
public void testContentEnricher() {
    QueueChannel replyChannel = new QueueChannel();
    Message<?> message = MessageBuilder.withPayload(new TestPojo("Bar"))
            .setHeader(MessageHeaders.REPLY_CHANNEL, replyChannel).build();
    this.enricherInput.send(message);
    Message<?> receive = replyChannel.receive(5000);
    assertNotNull(receive);/* ww w  .  j  a v  a  2s  . c  o m*/
    assertEquals("Bar Bar", receive.getHeaders().get("foo"));
    Object payload = receive.getPayload();
    assertThat(payload, instanceOf(TestPojo.class));
    TestPojo result = (TestPojo) payload;
    assertEquals("Bar Bar", result.getName());
    assertNotNull(result.getDate());
    assertThat(new Date(), Matchers.greaterThanOrEqualTo(result.getDate()));
}

From source file:org.springframework.integration.dsl.test.IntegrationFlowTests.java

@Test
public void testContentEnricher2() {
    QueueChannel replyChannel = new QueueChannel();
    Message<?> message = MessageBuilder.withPayload(new TestPojo("Bar"))
            .setHeader(MessageHeaders.REPLY_CHANNEL, replyChannel).build();
    this.enricherInput2.send(message);
    Message<?> receive = replyChannel.receive(5000);
    assertNotNull(receive);// w  w  w. j av a  2  s.  co m
    assertNull(receive.getHeaders().get("foo"));
    Object payload = receive.getPayload();
    assertThat(payload, instanceOf(TestPojo.class));
    TestPojo result = (TestPojo) payload;
    assertEquals("Bar Bar", result.getName());
    assertNotNull(result.getDate());
    assertThat(new Date(), Matchers.greaterThanOrEqualTo(result.getDate()));
}

From source file:org.springframework.integration.dsl.test.IntegrationFlowTests.java

@Test
public void testContentEnricher3() {
    QueueChannel replyChannel = new QueueChannel();
    Message<?> message = MessageBuilder.withPayload(new TestPojo("Bar"))
            .setHeader(MessageHeaders.REPLY_CHANNEL, replyChannel).build();
    this.enricherInput3.send(message);
    Message<?> receive = replyChannel.receive(5000);
    assertNotNull(receive);/*from  w  w  w  .  j a v a  2 s . com*/
    assertEquals("Bar Bar", receive.getHeaders().get("foo"));
    Object payload = receive.getPayload();
    assertThat(payload, instanceOf(TestPojo.class));
    TestPojo result = (TestPojo) payload;
    assertEquals("Bar", result.getName());
    assertNull(result.getDate());
}