Example usage for org.springframework.integration.core MessagingTemplate MessagingTemplate

List of usage examples for org.springframework.integration.core MessagingTemplate MessagingTemplate

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.integration.core.*
  5. MessagingTemplate
  6. MessagingTemplate

Introduction

In this page you can find the example usage for org.springframework.integration.core MessagingTemplate MessagingTemplate.

Prototype

public MessagingTemplate(MessageChannel defaultChannel)

Source Link

Document

Create a MessagingTemplate with the given default channel.

Usage

From source file:siia.booking.integration.WeatherTest.java

@Autowired
@Qualifier("weatherRequests")
public void setChannel(MessageChannel messageChannel) {
    this.channelTemplate = new MessagingTemplate(messageChannel);
}

From source file:org.thingsplode.server.bus.executors.AbstractExecutor.java

@PostConstruct
public void init() {
    msgTemplate = new MessagingTemplate(errorChannel);
}

From source file:biz.c24.io.spring.integration.config.HeaderEnricherTests.java

@Before
public void before() {
    template = new MessagingTemplate(textInputChannel);
}

From source file:com.demo.ex.AsyncErrorHandlingTest.java

@Test
public void testError() {

    service.divideByZero(100); // The exception will happen in another thread.

    MessagingTemplate mt = new MessagingTemplate(errorChannel);
    Exception e = (Exception) mt.receiveAndConvert(Exception.class);
    assertNotNull(e);/*w  w w .  j  a  v a  2 s  . c  o  m*/
    e.printStackTrace();
}

From source file:com.demo.ex.SyncErrorHandlingWithHeaderTest.java

@Test
public void testConvertStringToUpperCase() {
    ApplicationContext context = new ClassPathXmlApplicationContext("/si-sync-header.xml",
            SyncErrorHandlingTest.class);

    SimpleGateway service = context.getBean(SimpleGateway.class);

    service.divideByZero(100); // The exception will happen in another thread.

    MessagingTemplate mt = new MessagingTemplate(context.getBean("myErrorChannel", MessageChannel.class));
    Exception e = (Exception) mt.receiveAndConvert(Exception.class);
    assertNotNull(e);//ww w  .j  av a  2  s . c o  m
    System.out.println(e);

}

From source file:com.demo.ex.AsyncErrorHandlingLayerTest.java

@Test
public void testConvertStringToUpperCase() {
    final ApplicationContext context = new ClassPathXmlApplicationContext("/si-async-layers.xml",
            AsyncErrorHandlingTest.class);

    final SimpleGateway service = context.getBean(SimpleGateway.class);

    service.divideByZero(100); // The exception will happen in another thread.

    MessagingTemplate mt = new MessagingTemplate(context.getBean("stage3Error", MessageChannel.class));
    mt.setReceiveTimeout(1000);/*  w  w  w.  j  a v  a 2s.c o m*/
    Exception e = (Exception) mt.receiveAndConvert(Exception.class);
    assertNotNull(e);
    System.out.println(e);
}

From source file:biz.c24.io.spring.integration.config.ValidatingHeaderEnricherTests.java

@Before
public void before() {
    template = new MessagingTemplate(inputChannel);
}

From source file:io.spring.batch.configuration.JobConfiguration.java

@Bean
public MessagingTemplate messageTemplate() {
    MessagingTemplate messagingTemplate = new MessagingTemplate(outboundRequests());

    messagingTemplate.setReceiveTimeout(60000000l);

    return messagingTemplate;
}

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  w  w  w . ja  v  a  2s.co  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));
}