/** * Returns a Message with the given object as its payload, unless the * object is already a Message in which case it will be returned as-is. * If the object is null, the returned Message will also be null. */ public Message<?> toMessage(Object object) { if (object == null) { return null; } if (object instanceof Message) { return (Message<?>) object; } return MessageBuilder.withPayload(object).build(); }
/** * {@inheritDoc} */ @Override protected Message<?> aggregateMessages(List<Message<?>> messages) { List<Object> payloads = new ArrayList<Object>(messages.size()); for (Message<?> message : messages) { payloads.add(message.getPayload()); } return MessageBuilder.withPayload(payloads).build(); }
/** * */ public Message<BlobDetails> receive() throws StorageCommunicationException { if (toBeReceived.isEmpty()) { doReceive(); } if (!toBeReceived.isEmpty()) { BlobDetails obj = toBeReceived.poll(); MessageBuilder<BlobDetails> builder = MessageBuilder.withPayload(obj); return builder.build(); } else { return null; } }
@Override public final void handleRequestMessage(Message<?> message, ReplyMessageHolder replyHolder) { if (!(message.getPayload() instanceof Serializable)) { throw new MessageHandlingException(message, this.getClass().getName() + " expects a Serializable payload type " + "but encountered [" + message.getPayload().getClass().getName() + "]"); } Message<?> requestMessage = MessageBuilder.fromMessage(message).build(); try { Message<?> reply = this.handlerProxy.handle(requestMessage); if (reply != null) { replyHolder.set(reply); } } catch (RemoteAccessException e) { throw new MessageHandlingException(message, "unable to handle message remotely", e); } }
protected final void sendReply(Message<?> message, MessageChannel defaultReplyChannel) { MessageChannel replyChannel = this.outputChannel; if (replyChannel == null) { replyChannel = this.resolveReplyChannelFromMessage(message); if (replyChannel == null) { replyChannel = defaultReplyChannel; } } if (replyChannel != null) { if (defaultReplyChannel != null && !defaultReplyChannel.equals(replyChannel)) { message = MessageBuilder.fromMessage(message) .setHeaderIfAbsent(MessageHeaders.REPLY_CHANNEL, defaultReplyChannel) .build(); } if (!this.channelTemplate.send(message, replyChannel)) { throw new MessageDeliveryException(message, "failed to send reply Message"); } } else if (logger.isWarnEnabled()) { logger.warn("unable to determine reply target for aggregation result: " + message); } }
public final Message<?> transform(Message<?> message) { try { Map<String, Object> headerMap = new HashMap<String, Object>(message.getHeaders()); this.transformHeaders(headerMap); return MessageBuilder.withPayload(message.getPayload()).copyHeaders(headerMap).build(); } catch (Exception e) { throw new MessagingException(message, "failed to transform message headers", e); } }
/** * @param message * @throws IOException */ public Message<byte[]> doTransform(Message<BlobDetails> message) throws BlobTransformException { if (LOG.isDebugEnabled()) { LOG.debug("Transform blob to byte array: '{}'", String.valueOf(message.getPayload())); } BlobDetails payload = message.getPayload(); MessageBuilder<byte[]> builder; InputStream input = getTemplate().receiveAsInputStream(payload.getContainerName(), payload.getName()); ByteArrayOutputStream output = new ByteArrayOutputStream(); try { IOUtils.copy(input, output); } catch (IOException e) { throw new BlobTransformException("Failed to copy blob [" + payload + "] byte stream to byte array", e); } builder = (MessageBuilder<byte[]>) MessageBuilder.withPayload(output.toByteArray())// .copyHeaders(message.getHeaders()); Message<byte[]> blobMessage = builder.build(); return blobMessage; } }
/** * @param message */ protected Message<String> doTransform(Message<BlobDetails> message) throws BlobTransformException { if (LOG.isDebugEnabled()) { LOG.debug("Transform blob to string: '{}'", String.valueOf(message.getPayload())); } BlobDetails payload = message.getPayload(); String blobAsString = getTemplate().receiveAsString(payload.getContainerName(), payload.getName()); MessageBuilder<String> builder = (MessageBuilder<String>) MessageBuilder.withPayload(blobAsString)// .copyHeaders(message.getHeaders()); Message<String> blobMessage = builder.build(); return blobMessage; } }
public final Message<?> transform(Message<?> message) { try { @SuppressWarnings("unchecked") U result = this.transformPayload((T) message.getPayload()); return MessageBuilder.withPayload(result).copyHeaders(message.getHeaders()).build(); } catch (MessageTransformationException e) { throw e; } catch (Exception e) { throw new MessageTransformationException(message, "failed to transform message payload", e); } }
@Override protected final void handleMessageInternal(Message<?> message) { ReplyMessageHolder replyMessageHolder = new ReplyMessageHolder(); this.handleRequestMessage(message, replyMessageHolder); if (replyMessageHolder.isEmpty()) { if (this.requiresReply) { throw new MessageHandlingException(message, "handler '" + this + "' requires a reply, but no reply was received"); } if (logger.isDebugEnabled()) { logger.debug("handler '" + this + "' produced no reply for request Message: " + message); } return; } MessageChannel replyChannel = this.resolveReplyChannel(message); MessageHeaders requestHeaders = message.getHeaders(); for (MessageBuilder<?> builder : replyMessageHolder.builders()) { builder.copyHeadersIfAbsent(requestHeaders); Message<?> replyMessage = builder.build(); if (!this.sendReplyMessage(replyMessage, replyChannel)) { throw new MessageDeliveryException(replyMessage, "failed to send reply Message"); } } }
public boolean dispatch(Message<?> message) { boolean dispatched = false; int sequenceNumber = 1; List<MessageHandler> handlers = this.getHandlers(); int sequenceSize = handlers.size(); for (final MessageHandler handler : handlers) { final Message<?> messageToSend = (!this.applySequence) ? message : MessageBuilder.fromMessage(message) .setSequenceNumber(sequenceNumber++) .setSequenceSize(sequenceSize) .setCorrelationId(message.getHeaders().getId()) .setHeader(MessageHeaders.ID, UUID.randomUUID()) .build(); if (this.taskExecutor != null) { this.taskExecutor.execute(new Runnable() { public void run() { invokeHandler(handler, messageToSend); } }); dispatched = true; } else { boolean success = this.invokeHandler(handler, messageToSend); dispatched = (success || dispatched); } } return dispatched; }
private Message<?> doSendAndReceive(Message<?> request, MessageChannel channel) { Object originalReplyChannelHeader = request.getHeaders().getReplyChannel(); Object originalErrorChannelHeader = request.getHeaders().getErrorChannel(); TemporaryReplyChannel replyChannel = new TemporaryReplyChannel(this.receiveTimeout); request = MessageBuilder.fromMessage(request) .setReplyChannel(replyChannel) .setErrorChannel(replyChannel) .build(); if (!this.doSend(request, channel)) { throw new MessageDeliveryException(request, "failed to send message to channel"); } Message<?> reply = this.doReceive(replyChannel); if (reply != null) { reply = MessageBuilder.fromMessage(reply) .setHeader(MessageHeaders.REPLY_CHANNEL, originalReplyChannelHeader) .setHeader(MessageHeaders.ERROR_CHANNEL, originalErrorChannelHeader) .build(); } return reply; }
.setCorrelationId(message.getHeaders().getId()) .setHeader(MessageHeaders.ID, UUID.randomUUID()) .build(); if (channel != null) { if (this.channelTemplate.send(messageToSend, channel)) {
@Override protected void processBarrier(MessageBarrier<List<Message<?>>> barrier) { if (!barrier.isComplete() && !CollectionUtils.isEmpty(barrier.getMessages())) { if (this.completionStrategy.isComplete(barrier.getMessages())) { barrier.setComplete(); } } if (barrier.isComplete()) { this.removeBarrier(barrier.getCorrelationKey()); Message<?> result = this.aggregateMessages(barrier.getMessages()); if (result != null) { if (result.getHeaders().getCorrelationId() == null) { result = MessageBuilder.fromMessage(result) .setCorrelationId(barrier.getCorrelationKey()) .build(); } this.sendReply(result, this.resolveReplyChannelFromMessage(barrier.getMessages().get(0))); } } }
message.getHeaders()).build(); } catch(Exception e) { if (e instanceof MessageTransformationException) {