How to use

setMessageListener

method

in

org.springframework.amqp.rabbit.listener.DirectMessageListenerContainer

@Override
public void setMessageListener(MessageListener messageListener) {
  if (messageListener instanceof ChannelAwareMessageListener) {
    super.setMessageListener((ChannelAwareMessageListener) (message, channel) -> {
      try {
        ((ChannelAwareMessageListener) messageListener).onMessage(message, channel);
      }
      finally {
        this.inUseConsumerChannels.remove(channel);
      }
    });
  }
  else {
    super.setMessageListener((ChannelAwareMessageListener) (message, channel) -> {
      try {
        messageListener.onMessage(message);
      }
      finally {
        this.inUseConsumerChannels.remove(channel);
      }
    });
  }
}

@Override
public void setMessageListener(MessageListener messageListener) {
  if (messageListener instanceof ChannelAwareMessageListener) {
    super.setMessageListener((ChannelAwareMessageListener) (message, channel) -> {
      try {
        ((ChannelAwareMessageListener) messageListener).onMessage(message, channel);
      }
      finally {
        this.inUseConsumerChannels.remove(channel);
      }
    });
  }
  else {
    super.setMessageListener((ChannelAwareMessageListener) (message, channel) -> {
      try {
        messageListener.onMessage(message);
      }
      finally {
        this.inUseConsumerChannels.remove(channel);
      }
    });
  }
}

@Test
public void testEvents() throws Exception {
  CachingConnectionFactory cf = new CachingConnectionFactory("localhost");
  DirectMessageListenerContainer container = new DirectMessageListenerContainer(cf);
  container.setQueueNames(EQ1, EQ2);
  final List<Long> times = new ArrayList<>();
  final CountDownLatch latch1 = new CountDownLatch(2);
  final CountDownLatch latch2 = new CountDownLatch(2);
  container.setApplicationEventPublisher(event -> {
    if (event instanceof ListenerContainerIdleEvent) {
      times.add(System.currentTimeMillis());
      latch1.countDown();
    }
    else if (event instanceof ListenerContainerConsumerTerminatedEvent) {
      latch2.countDown();
    }
  });
  container.setMessageListener(m -> { });
  container.setIdleEventInterval(50L);
  container.setBeanName("events");
  container.setConsumerTagStrategy(new Tag());
  container.afterPropertiesSet();
  container.start();
  assertTrue(latch1.await(10, TimeUnit.SECONDS));
  assertThat(times.get(1) - times.get(0), greaterThanOrEqualTo(50L));
  brokerRunning.deleteQueues(EQ1, EQ2);
  assertTrue(latch2.await(10, TimeUnit.SECONDS));
  container.stop();
  cf.destroy();
}

@Test
public void testDeferredAcks() throws Exception {
  CachingConnectionFactory cf = new CachingConnectionFactory("localhost");
  DirectMessageListenerContainer container = new DirectMessageListenerContainer(cf);
  final CountDownLatch latch = new CountDownLatch(2);
  container.setMessageListener(m -> {
    latch.countDown();
  });
  container.setQueueNames(Q1);
  container.setBeanName("deferredAcks");
  container.setMessagesPerAck(2);
  container.afterPropertiesSet();
  container.start();
  RabbitTemplate rabbitTemplate = new RabbitTemplate(cf);
  rabbitTemplate.convertAndSend(Q1, "foo");
  rabbitTemplate.convertAndSend(Q1, "bar");
  assertTrue(latch.await(10, TimeUnit.SECONDS));
  container.stop();
  cf.destroy();
}

container.setMessagesPerAck(10);
container.setAckTimeout(100);
container.setMessageListener(m -> {
  if (m.getMessageProperties().getDeliveryTag() == 19L) {
    throw new RuntimeException("TestNackAndPendingAcks");

@Test
public void testNonManagedContainerStopsWhenConnectionFactoryDestroyed() throws Exception {
  CachingConnectionFactory cf = new CachingConnectionFactory("localhost");
  ApplicationContext context = mock(ApplicationContext.class);
  cf.setApplicationContext(context);
  DirectMessageListenerContainer container = new DirectMessageListenerContainer(cf);
  final CountDownLatch latch = new CountDownLatch(1);
  container.setMessageListener(m -> {
    latch.countDown();
  });
  container.setQueueNames(Q1);
  container.setBeanName("stopAfterDestroy");
  container.setIdleEventInterval(500);
  container.setFailedDeclarationRetryInterval(500);
  container.afterPropertiesSet();
  container.start();
  new RabbitTemplate(cf).convertAndSend(Q1, "foo");
  assertTrue(latch.await(10, TimeUnit.SECONDS));
  cf.onApplicationEvent(new ContextClosedEvent(context));
  cf.destroy();
  int n = 0;
  while (n++ < 100 && container.isRunning()) {
    Thread.sleep(100);
  }
  assertFalse(container.isRunning());
}

@Test
public void testAdvice() throws Exception {
  CachingConnectionFactory cf = new CachingConnectionFactory("localhost");
  DirectMessageListenerContainer container = new DirectMessageListenerContainer(cf);
  container.setQueueNames(Q1, Q2);
  container.setConsumersPerQueue(2);
  final CountDownLatch latch = new CountDownLatch(2);
  container.setMessageListener(m -> latch.countDown());
  final CountDownLatch adviceLatch = new CountDownLatch(2);
  MethodInterceptor advice = i -> {
    adviceLatch.countDown();
    return i.proceed();
  };
  container.setAdviceChain(advice);
  container.setBeanName("advice");
  container.setConsumerTagStrategy(new Tag());
  container.afterPropertiesSet();
  container.start();
  RabbitTemplate template = new RabbitTemplate(cf);
  template.convertAndSend(Q1, "foo");
  template.convertAndSend(Q1, "bar");
  assertTrue(latch.await(10, TimeUnit.SECONDS));
  assertTrue(adviceLatch.await(10, TimeUnit.SECONDS));
  container.stop();
  assertTrue(consumersOnQueue(Q1, 0));
  assertTrue(consumersOnQueue(Q2, 0));
  assertTrue(activeConsumerCount(container, 0));
  assertEquals(0, TestUtils.getPropertyValue(container, "consumersByQueue", MultiValueMap.class).size());
  cf.destroy();
}

@Test
public void testNonManagedContainerDoesntStartWhenConnectionFactoryDestroyed() throws Exception {
  CachingConnectionFactory cf = new CachingConnectionFactory("localhost");
  ApplicationContext context = mock(ApplicationContext.class);
  cf.setApplicationContext(context);
  cf.addConnectionListener(connection -> {
    cf.onApplicationEvent(new ContextClosedEvent(context));
    cf.destroy();
  });
  DirectMessageListenerContainer container = new DirectMessageListenerContainer(cf);
  container.setMessageListener(m -> { });
  container.setQueueNames(Q1);
  container.setBeanName("stopAfterDestroyBeforeStart");
  container.afterPropertiesSet();
  container.start();
  int n = 0;
  while (n++ < 100 && container.isRunning()) {
    Thread.sleep(100);
  }
  assertFalse(container.isRunning());
}

container.setQueueNames(Q1, Q2);
container.setConsumersPerQueue(2);
container.setMessageListener(new MessageListenerAdapter((ReplyingMessageListener<String, String>) in -> {
  if ("foo".equals(in) || "bar".equals(in)) {
    return in.toUpperCase();

container.setConsumersPerQueue(2);
final AtomicReference<Channel> channel = new AtomicReference<>();
container.setMessageListener((ChannelAwareMessageListener) (m, c) -> {
  channel.set(c);
  throw new MessageConversionException("intended - should be wrapped in an AmqpRejectAndDontRequeueException");

DirectMessageListenerContainer container = new DirectMessageListenerContainer(cf);
container.setConsumersPerQueue(2);
container.setMessageListener(new MessageListenerAdapter((ReplyingMessageListener<String, String>) in -> {
  if ("foo".equals(in) || "bar".equals(in)) {
    return in.toUpperCase();

container.setQueueNames(Q1, Q2);
container.setConsumersPerQueue(4);
container.setMessageListener(new MessageListenerAdapter((ReplyingMessageListener<String, String>) in -> {
  if ("foo".equals(in) || "bar".equals(in)) {
    return in.toUpperCase();

DirectMessageListenerContainer container = new DirectMessageListenerContainer(cf);
container.setConsumersPerQueue(2);
container.setMessageListener(new MessageListenerAdapter((ReplyingMessageListener<String, String>) in -> {
  if ("foo".equals(in) || "bar".equals(in)) {
    return in.toUpperCase();

container.setConsumersPerQueue(2);
container.setConsumersPerQueue(2);
container.setMessageListener(m -> { });
container.setFailedDeclarationRetryInterval(500);
container.setBeanName("deleteQauto=" + autoDeclare);