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); } }
MessageBuilder<?> builder = MessageBuilder.fromMessage(message); for (Object keyObject : propertiesToSet.keySet()) { String key = (String) keyObject; builder.setHeader(key, propertiesToSet.getProperty(key)); return builder.build(); MessageBuilder<?> builder = MessageBuilder.fromMessage(message); for (Object key : attributesToSet.keySet()) { if (!(key instanceof String)) { "Map returned from a Transformer method must have String-typed keys"); builder.setHeader((String) key, attributesToSet.get(key)); return builder.build(); return MessageBuilder.withPayload(result).copyHeaders(message.getHeaders()).build();
/** * Create a builder for a new {@link Message} instance with the provided payload. * * @param payload the payload for the new message */ public static <T> MessageBuilder<T> withPayload(T payload) { MessageBuilder<T> builder = new MessageBuilder<T>(payload, null); return builder; }
/** * 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(); }
private void addReply(ReplyMessageHolder replyHolder, Object item, Object correlationId, int sequenceNumber, int sequenceSize) { replyHolder.add(item).setCorrelationId(correlationId) .setSequenceNumber(sequenceNumber) .setSequenceSize(sequenceSize) .setHeader(MessageHeaders.ID, UUID.randomUUID()); }
private MessageBuilder<?> createAndAddBuilder(Object messageOrPayload, boolean clearExistingValues) { MessageBuilder<?> builder = null; if (messageOrPayload instanceof MessageBuilder) { builder = (MessageBuilder<?>) messageOrPayload; } else if (messageOrPayload instanceof Message) { builder = MessageBuilder.fromMessage((Message<?>) messageOrPayload); } else { builder = MessageBuilder.withPayload(messageOrPayload); } synchronized (this.builders) { if (clearExistingValues) { this.builders.clear(); } this.builders.add(builder); } return builder; }
return message; return MessageBuilder.fromMessage(message).copyHeadersIfAbsent(headers).build(); return MessageBuilder.withPayload(payload).copyHeaders(headers).build();
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; }
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); } }
@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))); } } }
@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); } }
@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"); } } }
/** * Private constructor to be invoked from the static factory methods only. */ private MessageBuilder(T payload, Message<T> originalMessage) { Assert.notNull(payload, "payload must not be null"); this.payload = payload; this.originalMessage = originalMessage; if (originalMessage != null) { this.copyHeaders(originalMessage.getHeaders()); } }
for (MessageChannel channel : results) { final Message<?> messageToSend = (!this.applySequence) ? message : MessageBuilder.fromMessage(message) .setSequenceNumber(sequenceNumber++) .setSequenceSize(sequenceSize) .setCorrelationId(message.getHeaders().getId()) .setHeader(MessageHeaders.ID, UUID.randomUUID()) .build(); if (channel != null) { if (this.channelTemplate.send(messageToSend, channel)) {
/** * {@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 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); } }
/** * */ 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; } }
/** * Create a builder for a new {@link Message} instance pre-populated with * all of the headers copied from the provided message. The payload of the * provided Message will also be used as the payload for the new message. * * @param messageToCopy the Message from which the payload and all headers * will be copied */ public static <T> MessageBuilder<T> fromMessage(Message<T> message) { Assert.notNull(message, "message must not be null"); MessageBuilder<T> builder = new MessageBuilder<T>(message.getPayload(), message); return builder; }
/** * @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; } }