org.springframework.amqp.AmqpException Java Examples

@Override
public void send(String exchange, String routingKey, Message message, CorrelationData correlationData) throws AmqpException {
  // used when sending reply to AMQP requests that expected response message
  // or when not waiting for reply (for example sending out events).
  if (routingKey.startsWith(Address.AMQ_RABBITMQ_REPLY_TO + ".")) {
    super.send(exchange, routingKey, message, correlationData);
    spanDecorator.onSendReply(message.getMessageProperties(), exchange, routingKey, tracer.activeSpan());
    return; // don't create new span for response messages
  }
  try {
    createTracingHelper()
        .doWithTracingHeadersMessage(exchange, routingKey, message, (messageWithTracingHeaders) -> {
          super.send(exchange, routingKey, messageWithTracingHeaders, correlationData);
          return null;
        });
  } catch (Throwable throwable) {
    Throwables.propagateIfPossible(throwable, AmqpException.class);
  }
}
 

/**
 * bind new queue to existed exchange
 * @param exchangeName
 * @param queueName
 * @param routingKey
 */
public void bindQueue2Exchange(String exchangeName, String queueName, String routingKey){
    log.info("bindQueue2Exchange exchangeName:{},queueName:{},routingKey:{}",
            exchangeName, queueName, routingKey);
    Binding binding = BindingBuilder
            .bind(new Queue(queueName))
            .to(new DirectExchange(exchangeName))
            .with(routingKey);
    try {
        rabbitAdmin.declareBinding(binding);
    } catch (AmqpException ex) {
        log.error("Exchange or message queue not exists. ex:[]", ex);
        throw new FrontException(ConstantCode.EXCHANGE_OR_QUEUE_NOT_EXIST_ERROR);
    }
}
 

public void queueEvent(Device device, EventRoute eventRoute, Event event) {
    try {
        MessageProperties properties = new MessageProperties();
        properties.setHeader(RabbitMQDataConfig.MSG_HEADER_APIKEY, device.getApiKey());
        properties.setHeader(RabbitMQDataConfig.MSG_HEADER_EVENT_ROUTE_GUID, eventRoute.getGuid());

        Message message = new Message(toByteArray(event), properties);
        rabbitTemplate.convertAndSend("routed.events", message);

        if (!event.getIncoming().getChannel().equals("_echo")) {
            LOGGER.info(MessageFormat.format("Output tenant: {0} app: {1} channel: {2} device: {3} ts: {4} size: {5}",
                    device.getTenant().getDomainName(),
                    device.getApplication().getName(),
                    eventRoute.getOutgoing().getData().get("channel"),
                    eventRoute.getOutgoing().getDisplayName(),
                    event.getCreationTimestamp(),
                    event.getPayload().getBytes().length));

        }

    } catch (AmqpException ex) {
        LOGGER.error("AmqpException while sending message to RabbitMQ...", ex);
    }
}
 

public void sendMessage(Long orderId,int type,final long delayTimes){
    //发送信息格式：id&类型（1检查\检验\处置 4草药 5成药）
    String msg = orderId + "&" + type;
    //给延迟队列发送消息
    amqpTemplate.convertAndSend(QueueEnum.QUEUE_TTL_ORDER_CANCEL.getExchange(),
                                QueueEnum.QUEUE_TTL_ORDER_CANCEL.getRouteKey(),
                                msg,
            new MessagePostProcessor() {
                @Override
                public Message postProcessMessage(Message message) throws AmqpException {
                    //给消息设置延迟毫秒值
                     message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
                     return message;
             }
    });
    LOGGER.info("send order message msg:{}",msg);
}
 

public void sendMessage(Long orderId,int type,final long delayTimes){
    //发送信息格式：id&类型（1检查\检验\处置 4草药 5成药）
    String msg = orderId + "&" + type;
    //给延迟队列发送消息
    amqpTemplate.convertAndSend(QueueEnum.QUEUE_TTL_ORDER_CANCEL.getExchange(),
                                QueueEnum.QUEUE_TTL_ORDER_CANCEL.getRouteKey(),
                                msg,
            new MessagePostProcessor() {
                @Override
                public Message postProcessMessage(Message message) throws AmqpException {
                    //给消息设置延迟毫秒值
                     message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
                     return message;
             }
    });
    LOGGER.info("send order message msg:{}",msg);
}
 

public void sendMessage(Long orderId,int type,final long delayTimes){
    //发送信息格式：id&类型（1检查\检验\处置 4草药 5成药）
    String msg = orderId + "&" + type;
    //给延迟队列发送消息
    amqpTemplate.convertAndSend(QueueEnum.QUEUE_TTL_ORDER_CANCEL.getExchange(),
                                QueueEnum.QUEUE_TTL_ORDER_CANCEL.getRouteKey(),
                                msg,
            new MessagePostProcessor() {
                @Override
                public Message postProcessMessage(Message message) throws AmqpException {
                    //给消息设置延迟毫秒值
                     message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
                     return message;
             }
    });
    LOGGER.info("send order message msg:{}",msg);
}
 

public void sendMessage(Long orderId,int type,final long delayTimes){
    //发送信息格式：id&类型（1检查\检验\处置 4草药 5成药）
    String msg = orderId + "&" + type;
    //给延迟队列发送消息
    amqpTemplate.convertAndSend(QueueEnum.QUEUE_TTL_ORDER_CANCEL.getExchange(),
                                QueueEnum.QUEUE_TTL_ORDER_CANCEL.getRouteKey(),
                                msg,
            new MessagePostProcessor() {
                @Override
                public Message postProcessMessage(Message message) throws AmqpException {
                    //给消息设置延迟毫秒值
                     message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
                     return message;
             }
    });
    LOGGER.info("send order message msg:{}",msg);
}
 

public void sendMessage(final String serviceName, final String serviceMethodName,final String correlationId, Object request) {
	logger.info("sendMessage [this.{}, serviceMethodName:{} serviceName:{} correlationId: {}]", this.getClass(), serviceMethodName, serviceName, correlationId);
	rabbitTemplate.setCorrelationKey(correlationId);
	rabbitTemplate.convertAndSend(routingkey, request, new MessagePostProcessor() {            
    	@Override
        public Message postProcessMessage(Message message) throws AmqpException {
            message.getMessageProperties().setAppId(appId);
            message.getMessageProperties().setTimestamp(new Date());
            message.getMessageProperties().setMessageId(UUID.randomUUID().toString());
            message.getMessageProperties().setCorrelationId(correlationId.getBytes());
            message.getMessageProperties().setHeader("ServiceMethodName", serviceMethodName);
            message.getMessageProperties().setHeader("ServiceName", serviceName);
            return message;
        }
    }, new CorrelationData(correlationId));
}
 

@Test
public void doNotCrashWhenNoQueue() throws Exception {
    doThrow(new AmqpException("test error")).when(rabbitTemplate).convertAndSend(anyString(), any(Shipment.class));
    Shipment original = new Shipment("someName");
    Shipment saved = shippingController.postShipping(original);
    verify(rabbitTemplate, times(1)).convertAndSend(anyString(), any(Shipment.class));
    assertThat(original, is(equalTo(saved)));
}
 

public <T> T doWithTracingHeadersMessage(String exchange, String routingKey, Object message, ProceedFunction<T> proceedCallback)
    throws Throwable {

  if (routingKey != null && routingKey.startsWith(Address.AMQ_RABBITMQ_REPLY_TO + ".")) {
    // don't create new span for response messages when sending reply to AMQP requests that expected response message
    Message convertedMessage = convertMessageIfNecessary(message);
    spanDecorator.onSendReply(convertedMessage.getMessageProperties(), exchange, routingKey, tracer.activeSpan());
    return proceedCallback.apply(convertedMessage);
  }

  Message messageWithTracingHeaders = doBefore(exchange, routingKey, message);

  try {

    T resp = proceedCallback.apply(messageWithTracingHeaders);

    if (resp == null && nullResponseMeansError) {
      Span span = tracer.scopeManager().activeSpan();
      spanDecorator.onError(null, span);
      long replyTimeout = (long) ReflectionUtils.getField(FIELD_REPLY_TIMEOUT, rabbitTemplate);
      span.log("Timeout: AMQP request message handler hasn't sent reply AMQP message in " + replyTimeout + "ms");
    }
    return resp;
  } catch (AmqpException ex) {
    spanDecorator.onError(ex, tracer.scopeManager().activeSpan());
    throw ex;
  } finally {
    Optional.ofNullable(tracer.scopeManager().activeSpan())
        .ifPresent(Span::finish);
    scope.close();
  }
}
 

public void sendMessage(Long orderId,final long delayTimes){
    //给延迟队列发送消息
    amqpTemplate.convertAndSend(QueueEnum.QUEUE_TTL_ORDER_CANCEL.getExchange(), QueueEnum.QUEUE_TTL_ORDER_CANCEL.getRouteKey(), orderId, new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            //给消息设置延迟毫秒值
            message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
            return message;
        }
    });
    LOGGER.info("send orderId:{}",orderId);
}
 

@Override
public void notifyPayOrder(NotifyBean notifyBean, int count) {
	rabbitTemplate.convertAndSend(RabbitConfiguration.PAY_NOTIFY_DELAY_PRE_MESSAGE_TTL,
			notifyBean, new MessagePostProcessor() {

				@Override
				public Message postProcessMessage(Message message) throws AmqpException {
					message.getMessageProperties().setExpiration(count + "");
					message.getMessageProperties().setDeliveryMode(
							MessageDeliveryMode.PERSISTENT);
					return message;
				}
			});
}
 

private Object send(String exchangeName, Object msg, MessageConverter messageConverter, SendTypeEnum type,
                    String routingKey, int expiration, int priority) throws Exception {
    check(exchangeName, routingKey);

    Object obj = null;
    String msgId = UUID.randomUUID().toString();
    EventMessage eventMessage = new EventMessage(exchangeName, routingKey, type.toString(), msg, null, msgId);
    MessageProperties messageProperties = new MessageProperties();
    //过期时间
    if (expiration > 0) {
        messageProperties.setExpiration(String.valueOf(expiration));
    }
    //消息优先级
    if (priority > 0) {
        messageProperties.setPriority(priority);
    }
    messageProperties.setMessageId(msgId);
    // 设置消息持久化
    messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
    Message message = messageConverter.toMessage(eventMessage, messageProperties);
    rabbitmqFactory.setCorrelationData(msgId, null, eventMessage, null);
    try {
        if (SendTypeEnum.RPC.equals(type)) {
            obj = eventAmqpTemplate.convertSendAndReceive(routingKey, message);
        } else {
            eventAmqpTemplate.send(exchangeName, routingKey, message);
        }
    } catch (AmqpException e) {
        logger.error("send event fail. Event Message : [{}]", eventMessage, e);
        throw new Exception("send event fail", e);
    }
    return obj;
}
 

private Object sendWithEM(EventMessage eventMessage, int expiration, int priority, SendTypeEnum type) throws Exception {

        Object obj = null;
        MessageProperties messageProperties = new MessageProperties();
        //过期时间
        if (expiration > 0) {
            messageProperties.setExpiration(String.valueOf(expiration));
        }
        //消息优先级
        if (priority > 0) {
            messageProperties.setPriority(priority);
        }
        messageProperties.setMessageId(eventMessage.getMessageId());
        // 设置消息持久化
        messageProperties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
        Message message = messageConverter.toMessage(eventMessage, messageProperties);
        rabbitmqFactory.setCorrelationData(eventMessage.getMessageId(), eventMessage.getCoordinator(), eventMessage, null);
        try {
            if (SendTypeEnum.RPC.equals(type)) {
                obj = eventAmqpTemplate.convertSendAndReceive(eventMessage.getRoutingKey(), message);
            } else {
                eventAmqpTemplate.send(eventMessage.getExchangeName(), eventMessage.getRoutingKey(), message);
            }
        } catch (AmqpException e) {
            logger.error("send event fail. Event Message : [{}]", eventMessage, e);
            throw new Exception("send event fail", e);
        }
        return obj;
    }
 

public void sendMessage(Long orderId,final long delayTimes){
    //给延迟队列发送消息
    amqpTemplate.convertAndSend(QueueEnum.QUEUE_TTL_ORDER_CANCEL.getExchange(), QueueEnum.QUEUE_TTL_ORDER_CANCEL.getRouteKey(), orderId, new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            //给消息设置延迟毫秒值
            message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
            return message;
        }
    });
    LOGGER.info("send orderId:{}",orderId);
}
 

@Override
public void send(String msg, long delay) {
	_log.info("发送MQ延时消息:msg={},delay={}", msg, delay);
	rabbitTemplate.convertAndSend(PAY_NOTIFY_EXCHANGE_NAME, PAY_NOTIFY_QUEUE_NAME, msg, new MessagePostProcessor() {
		public Message postProcessMessage(Message message) throws AmqpException {
			message.getMessageProperties().setDelay((int) delay);
			return message;
		}
	});
}
 

@ResponseStatus(HttpStatus.OK)
@RequestMapping(method = RequestMethod.GET, path = "/health")
public
@ResponseBody
Map<String, List<HealthCheck>> getHealth() {
    Map<String, List<HealthCheck>> map = new HashMap<String, List<HealthCheck>>();
    List<HealthCheck> healthChecks = new ArrayList<HealthCheck>();
    Date dateNow = Calendar.getInstance().getTime();

    HealthCheck rabbitmq = new HealthCheck("shipping-rabbitmq", "OK", dateNow);
    HealthCheck app = new HealthCheck("shipping", "OK", dateNow);

    try {
        this.rabbitTemplate.execute(new ChannelCallback<String>() {
            @Override
            public String doInRabbit(Channel channel) throws Exception {
                Map<String, Object> serverProperties = channel.getConnection().getServerProperties();
                return serverProperties.get("version").toString();
            }
        });
    } catch ( AmqpException e ) {
        rabbitmq.setStatus("err");
    }

    healthChecks.add(rabbitmq);
    healthChecks.add(app);

    map.put("health", healthChecks);
    return map;
}
 

public void sendOrder(Order order) {
  rabbit.convertAndSend("tacocloud.order.queue", order,
      new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message)
            throws AmqpException {
          MessageProperties props = message.getMessageProperties();
          props.setHeader("X_ORDER_SOURCE", "WEB");
          return message;
        } 
      });
}
 

public void sendEvent(String apiKey, String channel, byte[] payload) {

        try {
            MessageProperties properties = new MessageProperties();
            properties.setHeader(RabbitMQConfig.MSG_HEADER_APIKEY, apiKey);
            properties.setHeader(RabbitMQConfig.MSG_HEADER_CHANNEL, channel);

            Message message = new Message(payload, properties);

            rabbitTemplate.convertAndSend("data.sub", message);
        } catch (AmqpException ex) {
            LOGGER.error("AmqpException while sending message to RabbitMQ...", ex);
        }
    }
 

public void sendConfig(String apiKey, String config) {

        try {
            MessageProperties properties = new MessageProperties();
            properties.setHeader(RabbitMQConfig.MSG_HEADER_APIKEY, apiKey);

            Message message = new Message(config.getBytes("UTF-8"), properties);

            rabbitTemplate.convertAndSend("mgmt.config.sub", message);
        } catch (AmqpException | UnsupportedEncodingException ex) {
            LOGGER.error("AmqpException while sending message to RabbitMQ...", ex);
        }

    }
 

public void queueEventDataPub(String apiKey, String channel, Long epochMilli, byte[] payload) {
    try {
        MessageProperties properties = new MessageProperties();
        properties.setHeader(RabbitMQConfig.MSG_HEADER_APIKEY, apiKey);
        properties.setHeader(RabbitMQConfig.MSG_HEADER_CHANNEL, channel);
        properties.setHeader(RabbitMQConfig.MSG_HEADER_TIMESTAMP, epochMilli);

        Message message = new Message(payload, properties);

        rabbitTemplate.convertAndSend("data.pub", message);
    } catch (AmqpException ex) {
        LOGGER.error("AmqpException while sending message to RabbitMQ...", ex);
    }
}
 

@Test
public void test() throws Exception {
	Advice[] adviceChain = TestUtils.getPropertyValue(this.container, "adviceChain", Advice[].class);
	assertEquals(1, adviceChain.length);
	RetryTemplate retryTemplate = TestUtils.getPropertyValue(adviceChain[0], "retryOperations",
			RetryTemplate.class);
	assertEquals(5, TestUtils.getPropertyValue(retryTemplate, "retryPolicy.maxAttempts"));
	assertEquals(123L, TestUtils.getPropertyValue(retryTemplate, "backOffPolicy.initialInterval"));
	assertEquals(345L, TestUtils.getPropertyValue(retryTemplate, "backOffPolicy.maxInterval"));
	assertEquals(1.5, TestUtils.getPropertyValue(retryTemplate, "backOffPolicy.multiplier"));
	assertEquals("scsapp-testq", this.container.getQueueNames()[0]);
	assertFalse(TestUtils.getPropertyValue(this.container, "defaultRequeueRejected", Boolean.class));
	assertEquals(2, TestUtils.getPropertyValue(this.container, "concurrentConsumers"));
	assertEquals(3, TestUtils.getPropertyValue(this.container, "maxConcurrentConsumers"));
	assertEquals(AcknowledgeMode.NONE, TestUtils.getPropertyValue(this.container, "acknowledgeMode"));
	assertEquals(10, TestUtils.getPropertyValue(this.container, "prefetchCount"));
	assertEquals(5, TestUtils.getPropertyValue(this.container, "txSize"));

	this.rabbitTemplate.convertAndSend("", "scsapp-testq", "foo", new MessagePostProcessor() {

		@Override
		public org.springframework.amqp.core.Message postProcessMessage(
				org.springframework.amqp.core.Message message) throws AmqpException {
			message.getMessageProperties().getHeaders().put("bar", "baz");
			return message;
		}

	});
	Message<?> out = this.messageCollector.forChannel(this.channels.output()).poll(10,  TimeUnit.SECONDS);
	assertNotNull(out);
	assertEquals("foo", out.getPayload());
	assertEquals("baz", out.getHeaders().get("bar"));
	assertNull(out.getHeaders().get(AmqpHeaders.DELIVERY_MODE));
}
 

public void sendMessage(Long orderId,final long delayTimes){
    //给延迟队列发送消息
    amqpTemplate.convertAndSend(QueueEnum.QUEUE_TTL_ORDER_CANCEL.getExchange(), QueueEnum.QUEUE_TTL_ORDER_CANCEL.getRouteKey(), orderId, new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            //给消息设置延迟毫秒值
            message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
            return message;
        }
    });
    LOGGER.info("send delay message orderId:{}",orderId);
}
 

public void sendMsg(String queueName, Integer msg) {
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    System.out.println("Sender:" + sdf.format(new Date()));
    rabbitTemplate.convertAndSend("delayed_exchange", queueName, msg, new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            //限定延迟时间
            int delay_time = 100000;
            message.getMessageProperties().setHeader("x-delay", delay_time);
            return message;
        }
    });
}
 

public void unbindQueueFromExchange(String exchangeName, String queueName, String routingKey){
    log.info("unbindQueueFromExchange exchangeName:{},queueName:{},routingKey:{}",
            exchangeName, queueName, routingKey);
    Binding binding = BindingBuilder
            .bind(new Queue(queueName))
            .to(new DirectExchange(exchangeName))
            .with(routingKey);
    try {
        rabbitAdmin.removeBinding(binding);
    } catch (AmqpException ex) {
        log.error("Exchange or message queue not exists. ex:[]", ex);
        throw new FrontException(ConstantCode.EXCHANGE_OR_QUEUE_NOT_EXIST_ERROR);
    }
}
 

public void sendMessage(Long orderId,final long delayTimes){
    //给延迟队列发送消息
    amqpTemplate.convertAndSend(QueueEnum.QUEUE_TTL_ORDER_CANCEL.getExchange(), QueueEnum.QUEUE_TTL_ORDER_CANCEL.getRouteKey(), orderId, new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            //给消息设置延迟毫秒值
            message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
            return message;
        }
    });
    LOGGER.info("send orderId:{}",orderId);
}
 

public void sendMessage(Long orderId,final long delayTimes){
    //给延迟队列发送消息
    amqpTemplate.convertAndSend(QueueEnum.QUEUE_TTL_ORDER_CANCEL.getExchange(), QueueEnum.QUEUE_TTL_ORDER_CANCEL.getRouteKey(), orderId, new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            //给消息设置延迟毫秒值
            message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
            return message;
        }
    });
    LOGGER.info("send delay message orderId:{}",orderId);
}
 

public void sendMessage(Long orderId,final long delayTimes){
    //给延迟队列发送消息
    amqpTemplate.convertAndSend(QueueEnum.QUEUE_ORDER_PLUGIN_CANCEL.getExchange(), QueueEnum.QUEUE_ORDER_PLUGIN_CANCEL.getRouteKey(), orderId, new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            //给消息设置延迟毫秒值
            message.getMessageProperties().setHeader("x-delay",delayTimes);
            return message;
        }
    });
    LOGGER.info("send delay message orderId:{}",orderId);
}
 

public void sendMessage(Long orderId,final long delayTimes){
    //给延迟队列发送消息
    amqpTemplate.convertAndSend(QueueEnum.QUEUE_TTL_ORDER_CANCEL.getExchange(), QueueEnum.QUEUE_TTL_ORDER_CANCEL.getRouteKey(), orderId, new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            //给消息设置延迟毫秒值
            message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
            return message;
        }
    });
    LOGGER.info("send delay message orderId:{}",orderId);
}
 

public void sendMessage(Long orderId,final long delayTimes){
    //给延迟队列发送消息
    amqpTemplate.convertAndSend(QueueEnum.QUEUE_TTL_ORDER_CANCEL.getExchange(), QueueEnum.QUEUE_TTL_ORDER_CANCEL.getRouteKey(), orderId, new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            //给消息设置延迟毫秒值
            message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
            return message;
        }
    });
    LOGGER.info("send delay message orderId:{}",orderId);
}