com.nesscomputing.amqp.AmqpRunnableFactory java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 StringBuilder s =new StringBuilder()
new StringBuilder(32)
String str;new StringBuilder(str)
Smart code suggestions by Tabnine
}

@Override
protected void configure()
{
  final Named connectionNamed;
  final AmqpConfig amqpConfig;
  connectionNamed = Names.named(connectionName);
  bind(new TypeLiteral<PublisherCallback<Object>>() {}).annotatedWith(JsonMapper.class).to(JsonPublisherCallback.class).in(Scopes.SINGLETON);
  bind(new TypeLiteral<PublisherCallback<String>>() {}).to(StringPublisherCallback.class).in(Scopes.SINGLETON);
  amqpConfig = config.getBean(AmqpConfig.class, ImmutableMap.of("name", connectionName));
  bind(AmqpConfig.class).annotatedWith(connectionNamed).toInstance(amqpConfig);
  if (amqpConfig.isEnabled()) {
    LOG.info("Enabling AMQP for '%s'", connectionName);
    bind(ConnectionFactory.class).annotatedWith(connectionNamed).toProvider(new AmqpFactoryProvider(amqpConfig)).in(Scopes.SINGLETON);
    bind(AmqpRunnableFactory.class).annotatedWith(connectionNamed).toInstance(new AmqpRunnableFactory(connectionNamed));
  }
  else {
    LOG.info("Disabled AMQP for '%s'", connectionName);
  }
}

@Test
public void testSimpleProducer() throws Exception
{
  final ExchangePublisher<Object> exchangeConsumer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic");
  Assert.assertNotNull(exchangeConsumer);
}

@Test
public void stopConsumerWithNoMessages() throws Exception
{
  final ExchangeConsumer exchangeConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", new DummyMessageCallback());
  Assert.assertNotNull(exchangeConsumer);
  final Thread topicThread = new Thread(exchangeConsumer);
  topicThread.start();
  Thread.sleep(2000L);
  Assert.assertTrue(exchangeConsumer.isConnected());
  exchangeConsumer.shutdown();
  topicThread.interrupt();
  topicThread.join();
}

final ExchangeConsumer exchangeConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", callback);
final ExchangePublisher<Object> exchangeProducer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic");
final Thread consumerThread = new Thread(exchangeConsumer);
final Thread producerThread = new Thread(exchangeProducer);

@Test
public void testProduceConsume() throws Exception
{
  final CountingMessageCallback cmc = new CountingMessageCallback();
  final QueueConsumer queueConsumer = queueRunnableFactory.createQueueListener("test-queue", cmc);
  final QueuePublisher<Object> queuePublisher = queueRunnableFactory.createQueueJsonPublisher("test-queue");
  final Thread consumerThread = new Thread(queueConsumer);
  final Thread producerThread = new Thread(queuePublisher);
  consumerThread.start();
  producerThread.start();
  Thread.sleep(1000L);
  Assert.assertTrue(queueConsumer.isConnected());
  Assert.assertFalse(queuePublisher.isConnected());
  final int maxCount = 1000;
  for (int i = 0; i < maxCount; i++) {
    queuePublisher.put(format("hello, world %d", i));
  }
  Thread.sleep(DRAIN_SLEEP);
  Assert.assertTrue(queuePublisher.isEmpty());
  Assert.assertEquals(maxCount, cmc.getCount());
  queuePublisher.shutdown();
  queueConsumer.shutdown();
  producerThread.interrupt();
  consumerThread.interrupt();
  producerThread.join();
  consumerThread.join();
}

@Test
public void testSimpleProducer() throws Exception
{
  final QueuePublisher<Object> queuePublisher = queueRunnableFactory.createQueueJsonPublisher("test-queue");
  Assert.assertNotNull(queuePublisher);
}

@Test
public void stopConsumerWithNoMessages() throws Exception
{
  final QueueConsumer queueConsumer = queueRunnableFactory.createQueueListener("test-queue", new DummyMessageCallback());
  Assert.assertNotNull(queueConsumer);
  final Thread queueThread = new Thread(queueConsumer);
  queueThread.start();
  Thread.sleep(2000L);
  Assert.assertTrue(queueConsumer.isConnected());
  queueConsumer.shutdown();
  queueThread.interrupt();
  queueThread.join();
}

@Test
public void testProduceConsume() throws Exception
{
  final CountingMessageCallback cmc = new CountingMessageCallback();
  final ExchangeConsumer topicConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", cmc);
  final ExchangePublisher<Object> topicProducer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic");
  final Thread consumerThread = new Thread(topicConsumer);
  final Thread producerThread = new Thread(topicProducer);
  consumerThread.start();
  producerThread.start();
  Thread.sleep(1000L);
  Assert.assertTrue(topicConsumer.isConnected());
  Assert.assertFalse(topicProducer.isConnected());
  final int maxCount = 1000;
  for (int i = 0; i < maxCount; i++) {
    topicProducer.put(format("hello, world %d", i));
  }
  Thread.sleep(DRAIN_SLEEP);
  Assert.assertTrue(topicProducer.isEmpty());
  Assert.assertEquals(maxCount, cmc.getCount());
  topicProducer.shutdown();
  topicConsumer.shutdown();
  producerThread.interrupt();
  consumerThread.interrupt();
  producerThread.join();
  consumerThread.join();
}

final QueueConsumer queueConsumer1 = queueRunnableFactory.createQueueListener("test-queue", cmc1);
final QueueConsumer queueConsumer2 = queueRunnableFactory.createQueueListener("test-queue", cmc2);
final QueuePublisher<Object> queuePublisher = queueRunnableFactory.createQueueJsonPublisher("test-queue");
final Thread consumerThread1 = new Thread(queueConsumer1);
final Thread consumerThread2 = new Thread(queueConsumer2);

@Test
public void stopProducerWithNoMessages() throws Exception
{
  final QueuePublisher<Object> queuePublisher = queueRunnableFactory.createQueueJsonPublisher("test-queue");
  Assert.assertNotNull(queuePublisher);
  final Thread queueThread = new Thread(queuePublisher);
  queueThread.start();
  Thread.sleep(2000L);
  Assert.assertFalse(queuePublisher.isConnected());
  queuePublisher.shutdown();
  queueThread.interrupt();
  queueThread.join();
}

@Test
public void testSimpleConsumer() throws Exception
{
  final QueueConsumer queueConsumer = queueRunnableFactory.createQueueListener("test-queue", new DummyMessageCallback());
  Assert.assertNotNull(queueConsumer);
}

final ExchangeConsumer topicConsumer1 = exchangeRunnableFactory.createExchangeListener("test-topic", cmc1);
final ExchangeConsumer topicConsumer2 = exchangeRunnableFactory.createExchangeListener("test-topic", cmc2);
final ExchangePublisher<Object> topicProducer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic");
final Thread consumerThread1 = new Thread(topicConsumer1);
final Thread consumerThread2 = new Thread(topicConsumer2);

final QueueConsumer queueConsumer = queueRunnableFactory.createQueueListener("test-queue", cmc);
final QueuePublisher<Object> queuePublisher1 = queueRunnableFactory.createQueueJsonPublisher("test-queue");
final QueuePublisher<Object> queuePublisher2 = queueRunnableFactory.createQueueJsonPublisher("test-queue");
final Thread consumerThread = new Thread(queueConsumer);
final Thread producerThread1 = new Thread(queuePublisher1);

@Test
public void stopProducerWithNoMessages() throws Exception
{
  final ExchangePublisher<Object>topicProducer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic");
  Assert.assertNotNull(topicProducer);
  final Thread topicThread = new Thread(topicProducer);
  topicThread.start();
  Thread.sleep(2000L);
  Assert.assertFalse(topicProducer.isConnected());
  topicProducer.shutdown();
  topicThread.interrupt();
  topicThread.join();
}

@Test
public void testSimpleConsumer() throws Exception
{
  final ExchangeConsumer exchangeConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", new DummyMessageCallback());
  Assert.assertNotNull(exchangeConsumer);
}

final ExchangeConsumer topicConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", cmc);
final ExchangePublisher<Object> topicProducer1 = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic");
final ExchangePublisher<Object> topicProducer2 = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic");
final Thread consumerThread = new Thread(topicConsumer);
final Thread producerThread1 = new Thread(topicProducer1);

final QueueConsumer queueConsumer1 = queueRunnableFactory.createQueueListener("test-queue", cmc1);
final QueueConsumer queueConsumer2 = queueRunnableFactory.createQueueListener("test-queue", cmc2);
final QueuePublisher<Object> queuePublisher1 = queueRunnableFactory.createQueueJsonPublisher("test-queue");
final QueuePublisher<Object> queuePublisher2 = queueRunnableFactory.createQueueJsonPublisher("test-queue");
final Thread consumerThread1 = new Thread(queueConsumer1);
final Thread consumerThread2 = new Thread(queueConsumer2);

final ExchangeConsumer topicConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", callback);
final ExchangePublisher<Object> topicProducer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic");
final Thread consumerThread = new Thread(topicConsumer);
final Thread producerThread = new Thread(topicProducer);

final ExchangeConsumer topicConsumer1 = exchangeRunnableFactory.createExchangeListener("test-topic", cmc1);
final ExchangeConsumer topicConsumer2 = exchangeRunnableFactory.createExchangeListener("test-topic", cmc2);
final ExchangePublisher<Object> topicProducer1 = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic");
final ExchangePublisher<Object> topicProducer2 = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic");
final Thread consumerThread1 = new Thread(topicConsumer1);
final Thread consumerThread2 = new Thread(topicConsumer2);

final ExchangeConsumer topicConsumer = exchangeRunnableFactory.createExchangeListener("test-topic", callback);
final ExchangePublisher<Object> topicProducer = exchangeRunnableFactory.createExchangeJsonPublisher("test-topic");
final Thread consumerThread = new Thread(topicConsumer);
final Thread producerThread = new Thread(topicProducer);

Javadoc

Factory to create new Runnables to access exchanges and queues.

Most used methods

<init>
createExchangeJsonPublisher
Creates a new ExchangePublisher. The Publisher accepts arbitrary objects and uses the Jackson object
createExchangeListener
Creates a new ExchangeConsumer. For every message received (or when the timeout waiting for messages
createQueueJsonPublisher
Creates a new QueuePublisher. The Publisher accepts arbitrary objects and uses the Jackson object ma
createQueueListener
Creates a new QueueConsumer. For every message received (or when the timeout waiting for messages is

Popular in Java

Making http post requests using okhttp
onRequestPermissionsResult (Fragment)
setContentView (Activity)
putExtra (Intent)
SimpleDateFormat (java.text)
Formats and parses dates in a locale-sensitive manner. Formatting turns a Date into a String, and pa
Arrays (java.util)
This class contains various methods for manipulating arrays (such as sorting and searching). This cl
CountDownLatch (java.util.concurrent)
A synchronization aid that allows one or more threads to wait until a set of operations being perfor
Executor (java.util.concurrent)
An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
JarFile (java.util.jar)
JarFile is used to read jar entries and their associated data from jar files.
Filter (javax.servlet)
A filter is an object that performs filtering tasks on either the request to a resource (a servlet o
21 Best Atom Packages for 2021

How to useAmqpRunnableFactory in com.nesscomputing.amqp

Best Java code snippets using com.nesscomputing.amqp.AmqpRunnableFactory (Showing top 20 results out of 315)

How to use
AmqpRunnableFactory
in
com.nesscomputing.amqp