Example usage for org.springframework.integration.channel QueueChannel send

Introduction

In this page you can find the example usage for org.springframework.integration.channel QueueChannel send.

Prototype

@Override
public boolean send(Message<?> message) 

Source Link

Document

Send a message on this channel.

Usage

From source file:nhs.spring.integration.App.java

public static void main(String... args) {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
            "spring-integration-context.xml");
    GameMessageHandler gameHandler = new GameMessageHandler();
    GameGenerator gameGenerator = context.getBean(GameGenerator.class);

    context.start();//from  w  ww  .  j  a  v  a2  s .co m

    //MessageChannel input = context.getBean("input-channel", MessageChannel.class);
    //PollableChannel output = context.getBean("output-channel", PollableChannel.class);
    QueueChannel qChannel = context.getBean("game-channel", QueueChannel.class);

    PollingConsumer gameConsumer = new PollingConsumer(qChannel, gameHandler);
    gameConsumer.setReceiveTimeout(RECEIVE_TIMEOUT);
    gameConsumer.setBeanFactory(context);

    // Set up the poller using periodic trigger
    PeriodicTrigger periodicTrigger = new PeriodicTrigger(1000);
    periodicTrigger.setInitialDelay(5000);
    periodicTrigger.setFixedRate(false);

    PollerMetadata pollerMetadata = new PollerMetadata();
    pollerMetadata.setTrigger(periodicTrigger);
    pollerMetadata.setMaxMessagesPerPoll(3);

    gameConsumer.setPollerMetadata(pollerMetadata);

    // Starts the polling consumer in the other thread
    gameConsumer.start();

    Date today = new Date();

    // Generates messages and sends to the channel
    Game game = gameGenerator.generateGame("League of legend", "Riot Games", today, "Tom", "Michael", "AOS");

    qChannel.send(MessageBuilder.withPayload(game).build());

    /*
    PublishSubscribeChannel pubsubChannel = null;
            
    pubsubChannel.subscribe(gameHandler);
            
    input.send(MessageBuilder.withPayload("Spring Integration / Hello NHS").build());
    Message<?> reply = output.receive();
            
    System.out.println("Received :" + reply);
    */
}

---

From source file:org.bpmscript.integration.spring.SpringIntegrationTest.java

public void testSpringIntegration() throws Exception {
    final CountDownLatch latch = new CountDownLatch(2);
    MessageBus messageBus = new MessageBus();
    QueueChannel oneChannel = new QueueChannel(10);
    QueueChannel twoChannel = new QueueChannel(10);
    messageBus.registerChannel("onechannel", oneChannel);
    messageBus.registerChannel("twochannel", twoChannel);
    messageBus.registerHandler("onehandler", new MessageHandler() {

        public Message<?> handle(Message<?> message) {
            log.info(message.getPayload());
            latch.countDown();/*from   w ww .ja v  a 2 s  .  c  om*/
            return new StringMessage("Hi...");
        }

    }, new Subscription(oneChannel));
    messageBus.registerHandler("twohandler", new MessageHandler() {

        public Message<?> handle(Message<?> message) {
            log.info(message.getPayload());
            latch.countDown();
            return null;
        }

    }, new Subscription(twoChannel));
    messageBus.start();
    StringMessage stringMessage = new StringMessage("Hello World!");
    stringMessage.getHeader().setReturnAddress("twochannel");
    oneChannel.send(stringMessage);
    assertTrue(latch.await(2, TimeUnit.SECONDS));
    messageBus.stop();
}

---

From source file:org.springframework.integration.channel.QueueChannelTests.java

@Test
public void testSimpleSendAndReceive() throws Exception {
    final AtomicBoolean messageReceived = new AtomicBoolean(false);
    final CountDownLatch latch = new CountDownLatch(1);
    final QueueChannel channel = new QueueChannel();
    Log logger = spy(TestUtils.getPropertyValue(channel, "logger", Log.class));
    when(logger.isDebugEnabled()).thenReturn(true);
    when(logger.isTraceEnabled()).thenReturn(true);
    new DirectFieldAccessor(channel).setPropertyValue("logger", logger);
    new Thread(new Runnable() {
        @Override// w  w  w  .  j a v  a2 s .c o m
        public void run() {
            Message<?> message = channel.receive();
            if (message != null) {
                messageReceived.set(true);
                latch.countDown();
            }
        }
    }).start();
    assertFalse(messageReceived.get());
    channel.send(new GenericMessage<String>("testing"));
    latch.await(1000, TimeUnit.MILLISECONDS);
    assertTrue(messageReceived.get());
    ArgumentCaptor<String> preCaptor = ArgumentCaptor.forClass(String.class);
    ArgumentCaptor<String> postCaptor = ArgumentCaptor.forClass(String.class);
    verify(logger).trace(preCaptor.capture());
    verify(logger, times(3)).debug(postCaptor.capture());
    assertThat(preCaptor.getValue(), startsWith("preReceive"));
    assertThat(postCaptor.getValue(), startsWith("postReceive"));
}

---

From source file:org.springframework.integration.channel.QueueChannelTests.java

@Test
public void testImmediateReceive() throws Exception {
    final AtomicBoolean messageReceived = new AtomicBoolean(false);
    final QueueChannel channel = new QueueChannel();
    final CountDownLatch latch1 = new CountDownLatch(1);
    final CountDownLatch latch2 = new CountDownLatch(1);
    Executor singleThreadExecutor = Executors.newSingleThreadExecutor();
    Runnable receiveTask1 = new Runnable() {
        @Override/*from   w ww  . ja  v a  2  s . c  o m*/
        public void run() {
            Message<?> message = channel.receive(0);
            if (message != null) {
                messageReceived.set(true);
            }
            latch1.countDown();
        }
    };
    Runnable sendTask = new Runnable() {
        @Override
        public void run() {
            channel.send(new GenericMessage<String>("testing"));
        }
    };
    singleThreadExecutor.execute(receiveTask1);
    latch1.await();
    singleThreadExecutor.execute(sendTask);
    assertFalse(messageReceived.get());
    Runnable receiveTask2 = new Runnable() {
        @Override
        public void run() {
            Message<?> message = channel.receive(0);
            if (message != null) {
                messageReceived.set(true);
            }
            latch2.countDown();
        }
    };
    singleThreadExecutor.execute(receiveTask2);
    latch2.await();
    assertTrue(messageReceived.get());
}

---

From source file:org.springframework.integration.channel.QueueChannelTests.java

@Test
public void testImmediateSend() {
    QueueChannel channel = new QueueChannel(3);
    boolean result1 = channel.send(new GenericMessage<String>("test-1"));
    assertTrue(result1);//www . j  a v a  2 s  .  c  o m
    boolean result2 = channel.send(new GenericMessage<String>("test-2"), 100);
    assertTrue(result2);
    boolean result3 = channel.send(new GenericMessage<String>("test-3"), 0);
    assertTrue(result3);
    boolean result4 = channel.send(new GenericMessage<String>("test-4"), 0);
    assertFalse(result4);
}

---

From source file:org.springframework.integration.channel.QueueChannelTests.java

@Test
public void testBlockingSendWithNoTimeout() throws Exception {
    final QueueChannel channel = new QueueChannel(1);
    boolean result1 = channel.send(new GenericMessage<String>("test-1"));
    assertTrue(result1);// w ww.  j  ava  2 s  .c o m
    final AtomicBoolean sendInterrupted = new AtomicBoolean(false);
    final CountDownLatch latch = new CountDownLatch(1);
    Thread t = new Thread(new Runnable() {
        @Override
        public void run() {
            channel.send(new GenericMessage<String>("test-2"));
            sendInterrupted.set(true);
            latch.countDown();
        }
    });
    t.start();
    assertFalse(sendInterrupted.get());
    t.interrupt();
    latch.await();
    assertTrue(sendInterrupted.get());
}

---

From source file:org.springframework.integration.channel.QueueChannelTests.java

@Test
public void testBlockingSendWithTimeout() throws Exception {
    final QueueChannel channel = new QueueChannel(1);
    boolean result1 = channel.send(new GenericMessage<String>("test-1"));
    assertTrue(result1);//from ww w  .ja va  2  s .c om
    final AtomicBoolean sendInterrupted = new AtomicBoolean(false);
    final CountDownLatch latch = new CountDownLatch(1);
    Thread t = new Thread(new Runnable() {
        @Override
        public void run() {
            channel.send(new GenericMessage<String>("test-2"), 10000);
            sendInterrupted.set(true);
            latch.countDown();
        }
    });
    t.start();
    assertFalse(sendInterrupted.get());
    t.interrupt();
    latch.await();
    assertTrue(sendInterrupted.get());
}

---

From source file:org.springframework.integration.channel.QueueChannelTests.java

@Test
public void testClear() {
    QueueChannel channel = new QueueChannel(2);
    GenericMessage<String> message1 = new GenericMessage<String>("test1");
    GenericMessage<String> message2 = new GenericMessage<String>("test2");
    GenericMessage<String> message3 = new GenericMessage<String>("test3");
    assertTrue(channel.send(message1));
    assertTrue(channel.send(message2));/*from   w  ww . j  ava  2  s  . c  om*/
    assertFalse(channel.send(message3, 0));
    List<Message<?>> clearedMessages = channel.clear();
    assertNotNull(clearedMessages);
    assertEquals(2, clearedMessages.size());
    assertTrue(channel.send(message3));
}

---

From source file:org.springframework.integration.channel.QueueChannelTests.java

@Test
public void testReactorPersistentQueue() throws InterruptedException, IOException {
    final AtomicBoolean messageReceived = new AtomicBoolean(false);
    final CountDownLatch latch = new CountDownLatch(1);
    PersistentQueue<Message<?>> queue = new PersistentQueueSpec<Message<?>>()
            .codec(new JavaSerializationCodec<Message<?>>())
            .basePath(this.tempFolder.getRoot().getAbsolutePath()).get();

    final QueueChannel channel = new QueueChannel(queue);
    new Thread(new Runnable() {
        @Override/*from w  w w.  j a  v  a2  s. c o m*/
        public void run() {
            Message<?> message = channel.receive();
            if (message != null) {
                messageReceived.set(true);
                latch.countDown();
            }
        }
    }).start();
    assertFalse(messageReceived.get());
    channel.send(new GenericMessage<String>("testing"));
    latch.await(1000, TimeUnit.MILLISECONDS);
    assertTrue(messageReceived.get());

    final CountDownLatch latch1 = new CountDownLatch(2);

    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            while (true) {
                Message<?> message = channel.receive(100);
                if (message != null) {
                    latch1.countDown();
                    if (latch1.getCount() == 0) {
                        break;
                    }
                }
            }
        }
    });
    thread.start();

    Thread.sleep(200);
    channel.send(new GenericMessage<String>("testing"));
    channel.send(new GenericMessage<String>("testing"));
    assertTrue(latch1.await(1000, TimeUnit.MILLISECONDS));

    final AtomicBoolean receiveInterrupted = new AtomicBoolean(false);
    final CountDownLatch latch2 = new CountDownLatch(1);
    Thread t = new Thread(new Runnable() {
        @Override
        public void run() {
            Message<?> message = channel.receive(10000);
            receiveInterrupted.set(true);
            assertTrue(message == null);
            latch2.countDown();
        }
    });
    t.start();
    assertFalse(receiveInterrupted.get());
    t.interrupt();
    latch2.await();
    assertTrue(receiveInterrupted.get());

    receiveInterrupted.set(false);
    final CountDownLatch latch3 = new CountDownLatch(1);
    t = new Thread(new Runnable() {
        @Override
        public void run() {
            Message<?> message = channel.receive();
            receiveInterrupted.set(true);
            assertTrue(message == null);
            latch3.countDown();
        }
    });
    t.start();
    assertFalse(receiveInterrupted.get());
    t.interrupt();
    latch3.await();
    assertTrue(receiveInterrupted.get());

    GenericMessage<String> message1 = new GenericMessage<String>("test1");
    GenericMessage<String> message2 = new GenericMessage<String>("test2");
    assertTrue(channel.send(message1));
    assertTrue(channel.send(message2));
    List<Message<?>> clearedMessages = channel.clear();
    assertNotNull(clearedMessages);
    assertEquals(2, clearedMessages.size());

    clearedMessages = channel.clear();
    assertNotNull(clearedMessages);
    assertEquals(0, clearedMessages.size());

    // Test on artificial infinite wait
    // channel.receive();

    // Distributed scenario
    final CountDownLatch latch4 = new CountDownLatch(1);
    new Thread(new Runnable() {
        @Override
        public void run() {
            Message<?> message = channel.receive();
            if (message != null) {
                latch4.countDown();
            }
        }
    }).start();
    queue.add(new GenericMessage<String>("foo"));
    assertTrue(latch4.await(1000, TimeUnit.MILLISECONDS));
}

---