org.springframework.amqp.core.Queue Java Examples

@Test
public void 回復可能例外の場合はデフォルトの指定回数リトライが実行されて回復可能例外キューに配信される() throws Exception {
    container.setQueues(ctx.getBean("retryTestQueue", Queue.class));
    container.setMessageListener(new MessageListenerAdapter(new ApplicationRecoverableExceptionTestHandler(), ctx.getBean(MessageConverter.class)));
    recoverableContainer.setQueues(ctx.getBean("recoverableExceptionQueue", Queue.class));
    recoverableContainer.setMessageListener(new MessageListenerAdapter(new RecoverableTestHandler(), ctx.getBean(MessageConverter.class)));
    container.start();
    recoverableContainer.start();
    template.convertAndSend("retry.test.exchange", "retry.test.binding", new RetryTestBean("test"));
    assertThat(retry.await(30, TimeUnit.SECONDS), is(true));
    assertThat(retry.getCount(), is(0L));
    assertThat(recover.await(3, TimeUnit.SECONDS), is(true));
    assertThat(recover.getCount(), is(0L));
    container.stop();
    recoverableContainer.stop();
}
 

@PostConstruct
private void init() {
  log.info("Initialization of RabbitConfiguration");

  emsConnectionFactory = new CachingConnectionFactory();
  ((CachingConnectionFactory) emsConnectionFactory).setHost(brokerIp);
  ((CachingConnectionFactory) emsConnectionFactory).setPort(rabbitPort);
  ((CachingConnectionFactory) emsConnectionFactory).setUsername(emsRabbitUsername);
  ((CachingConnectionFactory) emsConnectionFactory).setPassword(emsRabbitPassword);

  rabbitAdmin = new RabbitAdmin(emsConnectionFactory);
  TopicExchange topicExchange = new TopicExchange("openbaton-exchange");
  rabbitAdmin.declareExchange(topicExchange);
  log.info("exchange declared");

  queueName_emsRegistrator = "ems." + vnfmHelper.getVnfmEndpoint() + ".register";
  rabbitAdmin.declareQueue(new Queue(queueName_emsRegistrator, durable, exclusive, autodelete));
}
 

@Bean
public Queue eventRoutesQueue() {
    boolean durable = true;
    boolean exclusive = false;
    boolean autoDelete = false;

    return new Queue("routed.events", durable, exclusive, autoDelete);
}
 

private Binding declareConsumerBindings(String name, String routingKey,
		ExtendedConsumerProperties<RabbitConsumerProperties> properties,
		Exchange exchange, boolean partitioned, Queue queue) {

	if (partitioned) {
		return partitionedBinding(name, exchange, queue, routingKey, properties.getExtension(),
				properties.getInstanceIndex());
	}
	else {
		return notPartitionedBinding(exchange, queue, routingKey, properties.getExtension());
	}
}
 

private RabbitTemplate queueAndExchangeSetup(BeanFactory context) {
    RabbitAdmin rabbitAdmin = context.getBean(RabbitAdmin.class);

    Queue queue = new Queue(QUEUE_NAME, false);
    rabbitAdmin.declareQueue(queue);
    TopicExchange exchange = new TopicExchange(EXCHANGE_NAME);
    rabbitAdmin.declareExchange(exchange);
    rabbitAdmin.declareBinding(BindingBuilder.bind(queue).to(exchange).with("test.*"));


    return context.getBean(RabbitTemplate.class);
}
 

@Bean
public Queue eventReceivingQueue() {
    if (queueName == null) {
        throw new IllegalStateException("No queue to listen to! Please specify the name of the queue to listen to with the property 'subscriber.queue'");
    }
    return new Queue(queueName);
}
 

@Test
public void testBadUserDeclarationsFatal() throws Exception {
	RabbitTestBinder binder = getBinder();
	ConfigurableApplicationContext context = binder.getApplicationContext();
	ConfigurableListableBeanFactory bf = context.getBeanFactory();
	bf.registerSingleton("testBadUserDeclarationsFatal",
			new Queue("testBadUserDeclarationsFatal", false));
	bf.registerSingleton("binder", binder);
	RabbitExchangeQueueProvisioner provisioner = TestUtils.getPropertyValue(binder,
			"binder.provisioningProvider", RabbitExchangeQueueProvisioner.class);
	bf.initializeBean(provisioner, "provisioner");
	bf.registerSingleton("provisioner", provisioner);
	context.addApplicationListener(provisioner);
	RabbitAdmin admin = new RabbitAdmin(rabbitAvailableRule.getResource());
	admin.declareQueue(new Queue("testBadUserDeclarationsFatal"));
	// reset the connection and configure the "user" admin to auto declare queues...
	rabbitAvailableRule.getResource().resetConnection();
	bf.initializeBean(admin, "rabbitAdmin");
	bf.registerSingleton("rabbitAdmin", admin);
	admin.afterPropertiesSet();
	// the mis-configured queue should be fatal
	Binding<?> binding = null;
	try {
		binding = binder.bindConsumer("input", "baddecls",
				this.createBindableChannel("input", new BindingProperties()),
				createConsumerProperties());
		fail("Expected exception");
	}
	catch (BinderException e) {
		assertThat(e.getCause()).isInstanceOf(AmqpIOException.class);
	}
	finally {
		admin.deleteQueue("testBadUserDeclarationsFatal");
		if (binding != null) {
			binding.unbind();
		}
	}
}
 

/**
 * If so requested, declare the DLX/DLQ and bind it. The DLQ is bound to the DLX with
 * a routing key of the original queue name because we use default exchange routing by
 * queue name for the original message.
 * @param baseQueueName The base name for the queue (including the binder prefix, if
 * any).
 * @param routingKey The routing key for the queue.
 * @param properties the properties.
 */
private void autoBindDLQ(final String baseQueueName, String routingKey,
		RabbitCommonProperties properties) {
	boolean autoBindDlq = properties.isAutoBindDlq();
	if (this.logger.isDebugEnabled()) {
		this.logger.debug("autoBindDLQ=" + autoBindDlq + " for: " + baseQueueName);
	}
	if (autoBindDlq) {
		String dlqName;
		if (properties.getDeadLetterQueueName() == null) {
			dlqName = constructDLQName(baseQueueName);
		}
		else {
			dlqName = properties.getDeadLetterQueueName();
		}
		Queue dlq = new Queue(dlqName, true, false, false,
				queueArgs(dlqName, properties, true));
		declareQueue(dlqName, dlq);
		String dlxName = deadLetterExchangeName(properties);
		if (properties.isDeclareDlx()) {
			declareExchange(dlxName,
					new ExchangeBuilder(dlxName,
							properties.getDeadLetterExchangeType()).durable(true)
									.build());
		}
		Map<String, Object> arguments = new HashMap<>(properties.getDlqBindingArguments());
		Binding dlqBinding = new Binding(dlq.getName(), DestinationType.QUEUE,
				dlxName, properties.getDeadLetterRoutingKey() == null ? routingKey
						: properties.getDeadLetterRoutingKey(),
				arguments);
		declareBinding(dlqName, dlqBinding);
		if (properties instanceof RabbitConsumerProperties
				&& ((RabbitConsumerProperties) properties).isRepublishToDlq()) {
			/*
			 * Also bind with the base queue name when republishToDlq is used, which
			 * does not know about partitioning
			 */
			declareBinding(dlqName, new Binding(dlq.getName(), DestinationType.QUEUE,
					dlxName, baseQueueName, arguments));
		}
	}
}
 

@Bean
Queue crawlArticleQueue() {
    return new Queue(QUEUE_GET_ARTICLE, false);
}
 

@Bean
public Queue queue() {
    return new Queue("tut6.rpc.requests");
}
 

@Bean
Queue replyToQueue() {
    return new Queue(ReplyToListener.REPLY_TO_QUEUE, false, false, true);
}
 

@Bean
public Queue queue(){
	return new Queue(queueName);
}
 

@Bean
public Binding locationDataQueueBinding(DirectExchange commodityExchange, Queue locationDataQueue) {
    return BindingBuilder.bind(locationDataQueue).to(commodityExchange).with(LOCATION_DATA_QUEUE);
}
 

@Bean("responsePaymentQueue")
public Queue responsePaymentQueue() {
  return new Queue(this.responsePaymentQueue, true, false, false);
}
 

@Bean
Binding bindingExchangeB(Queue BMessage, FanoutExchange fanoutExchange) {
    return BindingBuilder.bind(BMessage).to(fanoutExchange);
}
 

@Bean
public Queue webhookDeleteRequest() {
    return new Queue(QUEUE_WEBHOOK_DELETE_REQUEST);
}
 

@Bean
Queue queue() {
	return new Queue("SearchQ", false);
}
 

@Bean
Queue queue() {
	return new Queue("CheckINQ", false);
}
 

@Bean
Queue deadLetterQueue() {
    return QueueBuilder.durable(QUEUE_MESSAGES_DLQ).build();
}
 

@Bean
Queue queue() {
    return new Queue(queueName, false);
}
 

@Bean
Queue queue() {
	return new Queue("CheckINQ", false);
}
 

@Bean
public Queue patreonWebhookRequest() {
    return new Queue(QUEUE_PATREON_WEBHOOK_REQUEST);
}
 

@Bean
public Queue queue() {
    return new Queue(QUEUE_NAME, false);
}
 

@Bean
public Binding bindingAsync(DirectExchange exchange, Queue queue) {
     return BindingBuilder.bind(queue).to(exchange).with("packt");
}
 

@Bean
Queue queue() {
	return new Queue("SearchQ", false);
}
 

@Bean
public Queue queue() {
	return new Queue(QUEUE_NAME);
}
 

@Bean
Queue queue() {
	return new Queue("SearchQ", false);
}
 

@Bean
Queue queue() {
	return new Queue("TestQ", false);
}
 

public SendRequestEventLogin(Queue queue, RabbitTemplate rabbitTemplate) {
	this.rabbitTemplate = rabbitTemplate;
	this.queue = queue;
}
 

@Bean
public Queue refreshQueue() {
    return new Queue("rtu_refresh_queue", true);
}