Java Code Examples for org.springframework.amqp.core.Message#getBody()

@RabbitListener(queues = QUEUE_ASYNC_RPC)
public void processAsyncRpc(Message message, @Header(AmqpHeaders.REPLY_TO) String replyTo) {
    String body = new String(message.getBody(), Charset.forName("UTF-8"));
 User user = JacksonUtil.json2Bean(body, new TypeReference<User>(){});
    logger.info("recevie message {} and reply to {}, user.name={}", body, replyTo, user.getName());
    if (replyTo.startsWith("amq.rabbitmq.reply-to")) {
        logger.debug("starting with version 3.4.0, the RabbitMQ server now supports Direct reply-to");
    } else {
        logger.info("fall back to using a temporary reply queue");
    }
    ListenableFuture<String> asyncResult = asyncTask.expensiveOperation(body);
    asyncResult.addCallback(new ListenableFutureCallback<String>() {
        @Override
        public void onSuccess(String result) {
            amqpTemplate.convertAndSend(replyTo, result);
        }

        @Override
        public void onFailure(Throwable ex) {
            logger.error("接受到QUEUE_ASYNC_RPC失败", ex);
        }
    });
}
 

@Override
public void onMessage(Message message) {
    byte[] body = message.getBody();
    MessageProperties messageProperties = message.getMessageProperties();
    String contentType = messageProperties != null ? messageProperties.getContentType() : null;

    String rawEvent;
    if (body == null) {
        rawEvent = null;
    } else if (stringContentTypes.contains(contentType)) {
        rawEvent = new String(body, StandardCharsets.UTF_8);
    } else {
        rawEvent = Base64.getEncoder().encodeToString(body);
    }

    eventRegistry.eventReceived(inboundChannelModel, rawEvent);
}
 

/**
 * Method to validate if content type is set in the message properties.
 *
 * @param message
 *            the message to get validated
 */
private void checkContentTypeJson(final Message message) {
    if (message.getBody().length == 0) {
        return;
    }
    final MessageProperties messageProperties = message.getMessageProperties();
    final String headerContentType = (String) messageProperties.getHeaders().get("content-type");
    if (null != headerContentType) {
        messageProperties.setContentType(headerContentType);
    }
    final String contentType = messageProperties.getContentType();
    if (contentType != null && contentType.contains("json")) {
        return;
    }
    throw new AmqpRejectAndDontRequeueException("Content-Type is not JSON compatible");
}
 

public void doWork(Message message) {
    String routingKey = message.getMessageProperties().getReceivedRoutingKey();
    Matcher m = ESConstants.ROUTINGKEY_PATTERN.matcher(routingKey);
    try {
        if (m.find() && m.groupCount() == 3) {
            ESHandleMessage esHandleMessage = new ESHandleMessage(Long.parseLong(m.group(3)),
                    m.group(1), m.group(2), message.getBody());
            esHandleMessage.setEventGenerated(isGeneratedMessage(message));
            handleMsg(esHandleMessage);
        } else {
            lightLogger.warn("Message is invalid: " + routingKey);
        }
    } finally {
        lightLogger.info("Done");
    }

}
 

@Override
public void onMessage(Message message, Channel channel) throws Exception {
    Class<?> clazz;
    String className = message.getMessageProperties().getReceivedExchange();
    try {
        clazz = Class.forName(className);
        if (!IEventArg.class.isAssignableFrom(clazz)) {
            log.error("事件处理失败：" + className + "不是IEventArg的子类");
        }
    } catch (ClassNotFoundException ex) {
        log.error("事件处理失败：", ex);
        return;
    }

    String body = new String(message.getBody(), Charset.forName("utf8"));
    IEventArg eventArg = (IEventArg) JSON.parseObject(body,clazz);

    dispatcher.enqueue(eventArg);
    channel.basicAck(message.getMessageProperties().getDeliveryTag(), false); //确认消息成功消费
}
 

/**
 * 指令队列
 *
 * @param message
 */
@RabbitListener(queues = "rtu_inst_queue")
@RabbitHandler
public void command(Message message) throws IOException {
    String msg = new String(message.getBody());
    LOGGER.info("rtu-command: {}", msg);
    RTUCommandInfo commandInfo = JsonUtils.jsonStr2Obj(msg, RTUCommandInfo.class);
    if (commandInfo == null ||
            StringUtils.isEmpty(commandInfo.getSn()) ||
            StringUtils.isEmpty(commandInfo.getInstruction()) ||
            StringUtils.isEmpty(commandInfo.getInstructionType())) {
        LOGGER.warn("bad command: {}", commandInfo);
        return;
    }
    CommandHandler.writeCommand(commandInfo.getSn(), commandInfo.getInstruction(), commandInfo.getInstructionType());
}
 

private void sendReplyIfRequested(Message message) {
  MessageProperties messageProperties = message.getMessageProperties();
  String replyToProperty = messageProperties.getReplyTo();

  if (replyToProperty != null) {
    RabbitTemplate rabbitTemplate = rabbitTemplateProvider.getRabbitTemplate();
    Address replyTo = new Address(replyToProperty);
    String replyMsg = REPLY_MSG_PREFIX + new String(message.getBody(), UTF_8);
    Message replyMessage = rabbitTemplate.getMessageConverter().toMessage(replyMsg, null);

    Object addCustomResponseErrorMarkerHeader = messageProperties.getHeaders()
        .get(HEADER_ADD_CUSTOM_ERROR_HEADER_TO_RESPONSE);

    if (addCustomResponseErrorMarkerHeader != null) {
      replyMessage.getMessageProperties().setHeader(HEADER_CUSTOM_RESPONSE_ERROR_MARKER_HEADER, "dummy error message");
    }
    replyMessage.getMessageProperties().setCorrelationId(messageProperties.getCorrelationId());

    rabbitTemplate.convertAndSend(replyTo.getExchangeName(), replyTo.getRoutingKey(), replyMessage);
  }
}
 

private <T> T convertMessage(MessageConverter<T> messageConverter, Message message) {
    if (message == null) {
        return null;
    }
    byte[] body = message.getBody();
    return messageConverter.convertMessage(body);
}
 

/**
 * 刷新 iot信息
 *
 * @param message
 * @throws Exception
 */
@RabbitListener(queues = "rtu_refresh_queue")
@RabbitHandler
public void refreshIotInfo(Message message) throws Exception {
    String msg = new String(message.getBody());
    if (GlobalInfo.Global_Iot_Redis_Key.equals(msg)) {
        LOGGER.info("start refresh GlobalInfo, rtu_refresh key is : {}", msg);
        boolean flag = ioTService.refreshIotMapper2Global();
        if (flag) {
            ChannelManagerHandler.refreshRTUChannelInfo();
        }
    }
}
 

/**
 * 处理传输过来的数据
 * @param message 传送的消息内容
 * @param channel 实现通道
 * @return: void
 * @author: fruiqi
 * @date: 19-2-19 下午2:52
 */
@Override
public void onMessage(Message message, Channel channel) throws Exception {
    String mes = new String(message.getBody());
    logger.info("[INFO] message is {}",mes);

    // 手动应答 消息已消费
    channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);

}
 

@RabbitListener(bindings = {
        @QueueBinding(
                value = @Queue,
                exchange = @Exchange(value = RabbitMQConfiguration.EXCHANGE_NAME, type = ExchangeTypes.TOPIC),
                key = "upper"
        )
})
public void onMessage(Message message) {
    String text = new String(message.getBody());
    System.out.println("ToUpperCase.onMessage - " + text);
    String result = text.toUpperCase();
    template.convertAndSend(message.getMessageProperties().getReplyTo(), result);
}
 

@Override
public void onMessage(Message message, Channel channel) throws Exception {
    String msg = new String(message.getBody());

    System.out.println("----------- Message -----------");
    System.out.println(msg);
}
 

@Override
public <T> T receiveMessage(String queueName, MessageConverter<T> messageConverter) {
    Message message = rabbitTemplate.receive(queueName);
    if (message == null) {
        return null;
    }
    byte[] body = message.getBody();
    return messageConverter.convertMessage(body);
}
 

/**
 * 刷新 iot信息
 *
 * @param message
 * @throws Exception
 */
@RabbitListener(queues = "rtu_refresh_queue")
@RabbitHandler
public void refreshIotInfo(Message message) throws Exception {
    String msg = new String(message.getBody());
    if (GlobalInfo.Global_Iot_Redis_Key.equals(msg)) {
        LOGGER.info("start refresh GlobalInfo, rtu_refresh key is : {}", msg);
        boolean flag = ioTService.refreshIotMapper2Global();
        if (flag) {
            ChannelManagerHandler.refreshRTUChannelInfo();
        }
    }
}
 

@Override
public Object fromMessage(Message message) throws MessageConversionException {
	System.err.println("-----------PDF MessageConverter----------");
	
	byte[] body = message.getBody();
	String fileName = UUID.randomUUID().toString();
	String path = "d:/010_test/" + fileName + ".pdf";
	File f = new File(path);
	try {
		Files.copy(new ByteArrayInputStream(body), f.toPath());
	} catch (IOException e) {
		e.printStackTrace();
	}
	return f;
}
 

@Override
public Object fromMessage(Message message) throws MessageConversionException {
	String contentType = message.getMessageProperties().getContentType();
	// testSendMessage4Text
	if(null != contentType && contentType.contains("text")) {
		return new String(message.getBody());
	}
	return message.getBody();
}
 

@Override
public Object fromMessage(Message message) {
  return message.getBody();
}
 

@Override
public Object fromMessage(Message message) throws MessageConversionException {
	return message.getBody();
}
 

protected static boolean isMessageBodyEmpty(final Message message) {
    return message.getBody() == null || message.getBody().length == 0;
}
 

@Override
public void onMessage(Message message) {
	 String messageBody= new String(message.getBody());
	   // Retrieve the PO
        
	
}