@Override protected MutableMessage<?> buildMessage(MutableMessageHeaders headers, Object payload, JsonNode root, DeserializationContext ctxt) throws IOException { return new MutableMessage<Object>(payload, headers); }
/** * Private constructor to be invoked from the static factory methods only. */ private MutableMessageBuilder(Message<T> message) { Assert.notNull(message, "message must not be null"); if (message instanceof MutableMessage) { this.mutableMessage = (MutableMessage<T>) message; } else { this.mutableMessage = new MutableMessage<T>(message.getPayload(), message.getHeaders()); } this.headers = this.mutableMessage.getRawHeaders(); }
@SuppressWarnings("unchecked") @Override public byte[] fromMessage(Message<?> message) throws Exception { Map<String, Object> headersToEncode = this.allHeaders ? message.getHeaders() : pruneHeaders(message.getHeaders()); if (this.rawBytes && message.getPayload() instanceof byte[]) { return fromBytesPayload((byte[]) message.getPayload(), headersToEncode); } else { Message<?> messageToEncode = message; if (!this.allHeaders) { if (!headersToEncode.containsKey(MessageHeaders.ID)) { headersToEncode.put(MessageHeaders.ID, MessageHeaders.ID_VALUE_NONE); } if (!headersToEncode.containsKey(MessageHeaders.TIMESTAMP)) { headersToEncode.put(MessageHeaders.TIMESTAMP, -1L); } messageToEncode = new MutableMessage<>(message.getPayload(), headersToEncode); } return this.objectMapper.writeValueAsBytes(messageToEncode); } }
/** * Create a builder for a new {@link Message} instance with the provided payload. * The {@code generateHeaders} flag allows to disable {@link MessageHeaders#ID} * and {@link MessageHeaders#TIMESTAMP} headers generation. * @param payload the payload for the new message * @param generateHeaders whether generate {@link MessageHeaders#ID} * and {@link MessageHeaders#TIMESTAMP} headers * @param <T> The type of the payload. * @return A MutableMessageBuilder. * @since 5.0 */ public static <T> MutableMessageBuilder<T> withPayload(T payload, boolean generateHeaders) { MutableMessage<T> message; if (generateHeaders) { message = new MutableMessage<>(payload); } else { message = new MutableMessage<>(payload, new MutableMessageHeaders(null, MessageHeaders.ID_VALUE_NONE, -1L)); } return fromMessage(message); }
private Object doMput(Message<?> requestMessage) { File file = null; Object payload = requestMessage.getPayload(); if (payload instanceof File) { file = (File) payload; } else if (payload instanceof String) { file = new File((String) payload); } else if (!(payload instanceof Collection)) { throw new IllegalArgumentException( "Only File or String payloads (or Collection of File/String) allowed for 'mput', received: " + payload.getClass()); } if ((payload instanceof Collection)) { return ((Collection<?>) payload).stream() .map(p -> doMput(new MutableMessage<>(p, requestMessage.getHeaders()))) .collect(Collectors.toList()); } else if (!file.isDirectory()) { return doPut(requestMessage); } else { File localDir = file; return this.remoteFileTemplate.invoke(t -> mPut(requestMessage, t.getSession(), localDir)); } }
for (File filteredFile : filteredFiles) { if (!filteredFile.isDirectory()) { String path = doPut(new MutableMessage<>(filteredFile, requestMessage.getHeaders()), subDirectory); if (path == null) { //NOSONAR - false positive if (logger.isDebugEnabled()) {
@SuppressWarnings("unchecked") public <T> T invoke(ParametersWrapper parameters) throws Exception { Message<?> message = parameters.getMessage(); if (this.canProcessMessageList) { message = new MutableMessage<>(parameters.getMessages(), parameters.getHeaders()); } return (T) this.invocableHandlerMethod.invoke(message); }
@Test public void testMessageIdTimestampRemains() { UUID uuid = UUID.randomUUID(); long timestamp = System.currentTimeMillis(); Object payload = new Object(); Map<String, Object> headerMap = new HashMap<>(); headerMap.put(MessageHeaders.ID, uuid); headerMap.put(MessageHeaders.TIMESTAMP, timestamp); MutableMessage<Object> mutableMessage = new MutableMessage<>(payload, headerMap); MutableMessageHeaders headers = mutableMessage.getHeaders(); assertThat(headers.getRawHeaders(), hasEntry(MessageHeaders.ID, uuid)); assertThat(headers.getRawHeaders(), hasEntry(MessageHeaders.TIMESTAMP, timestamp)); }
@Test public void testMessageHeaderIsSerializable() { Object payload = new Object(); UUID uuid = UUID.nameUUIDFromBytes(((System.currentTimeMillis() - System.nanoTime()) + "").getBytes()); Long timestamp = System.currentTimeMillis(); // UUID as String; timestamp as String Map<String, Object> headerMapStrings = new HashMap<>(); headerMapStrings.put(MessageHeaders.ID, uuid.toString()); headerMapStrings.put(MessageHeaders.TIMESTAMP, timestamp.toString()); MutableMessage<Object> mutableMessageStrings = new MutableMessage<>(payload, headerMapStrings); assertEquals(uuid, mutableMessageStrings.getHeaders().getId()); assertEquals(timestamp, mutableMessageStrings.getHeaders().getTimestamp()); // UUID as byte[]; timestamp as Long Map<String, Object> headerMapByte = new HashMap<>(); byte[] uuidAsBytes = ByteBuffer.allocate(16) .putLong(uuid.getMostSignificantBits()) .putLong(uuid.getLeastSignificantBits()) .array(); headerMapByte.put(MessageHeaders.ID, uuidAsBytes); headerMapByte.put(MessageHeaders.TIMESTAMP, timestamp); MutableMessage<Object> mutableMessageBytes = new MutableMessage<>(payload, headerMapByte); assertEquals(uuid, mutableMessageBytes.getHeaders().getId()); assertEquals(timestamp, mutableMessageBytes.getHeaders().getTimestamp()); }
@Override protected MutableMessage<?> buildMessage(MutableMessageHeaders headers, Object payload, JsonNode root, DeserializationContext ctxt) throws IOException { return new MutableMessage<Object>(payload, headers); }
@Test public void testMessageHeaderIsSettable() { Object payload = new Object(); Map<String, Object> headerMap = new HashMap<>(); Map<String, Object> additional = new HashMap<>(); MutableMessage<Object> mutableMessage = new MutableMessage<>(payload, headerMap); MutableMessageHeaders headers = mutableMessage.getHeaders(); // Should not throw an UnsupportedOperationException headers.put("foo", "bar"); headers.put("eep", "bar"); headers.remove("eep"); headers.putAll(additional); assertThat(headers.getRawHeaders(), hasEntry("foo", "bar")); }
Message<?> mutableMessage = new MutableMessage<>(UUID.randomUUID()); Message<?> adviceMessage = new AdviceMessage<>("foo", genericMessage); ErrorMessage errorMessage = new ErrorMessage(new RuntimeException("test exception"), mutableMessage);
/** * Private constructor to be invoked from the static factory methods only. */ private MutableMessageBuilder(Message<T> message) { Assert.notNull(message, "message must not be null"); if (message instanceof MutableMessage) { this.mutableMessage = (MutableMessage<T>) message; } else { this.mutableMessage = new MutableMessage<T>(message.getPayload(), message.getHeaders()); } this.headers = this.mutableMessage.getRawHeaders(); }
@Filter(inputChannel = Processor.INPUT, outputChannel = Processor.OUTPUT) public boolean filter(Message<?> message) { if (message.getPayload() instanceof byte[]) { String contentType = message.getHeaders().containsKey(MessageHeaders.CONTENT_TYPE) ? message.getHeaders().get(MessageHeaders.CONTENT_TYPE).toString() : BindingProperties.DEFAULT_CONTENT_TYPE.toString(); if (contentType.contains("text") || contentType.contains("json") || contentType.contains("x-spring-tuple")) { message = new MutableMessage<>(new String(((byte[]) message.getPayload())), message.getHeaders()); } } return this.properties.getExpression().getValue(message, Boolean.class); }
@ServiceActivator(inputChannel = Processor.INPUT, outputChannel = Processor.OUTPUT) public Object transform(Message<?> message) { if (message.getPayload() instanceof byte[]) { String contentType = message.getHeaders().containsKey(MessageHeaders.CONTENT_TYPE) ? message.getHeaders().get(MessageHeaders.CONTENT_TYPE).toString() : BindingProperties.DEFAULT_CONTENT_TYPE.toString(); if (contentType.contains("text") || contentType.contains("json") || contentType.contains("x-spring-tuple")) { message = new MutableMessage<>(new String(((byte[]) message.getPayload())), message.getHeaders()); } } return properties.getExpression().getValue(message); }
@Override protected void handleMessageInternal(Message<?> message) throws Exception { if (message.getPayload() instanceof byte[]){ String contentType = message.getHeaders().containsKey(MessageHeaders.CONTENT_TYPE) ? message.getHeaders().get(MessageHeaders.CONTENT_TYPE).toString() : BindingProperties.DEFAULT_CONTENT_TYPE.toString(); if (contentType.contains("text") || contentType.contains("json") || contentType.contains("x-spring-tuple")) { message = new MutableMessage<>(new String(((byte[]) message.getPayload())), message.getHeaders()); } } super.handleMessageInternal(message); } };
@Test public void testCorrectMutableMessageAfterWrite() { MutableMessage<String> original = new MutableMessage<>("foo"); assertNull(MessageHistory.read(original)); Message<String> result1 = MessageHistory.write(original, new TestComponent(1)); assertThat(result1, instanceOf(MutableMessage.class)); assertSame(original, result1); MessageHistory history1 = MessageHistory.read(result1); assertNotNull(history1); assertEquals("testComponent-1", history1.toString()); Message<String> result2 = MessageHistory.write(result1, new TestComponent(2)); assertSame(original, result2); MessageHistory history2 = MessageHistory.read(result2); assertNotNull(history2); assertEquals("testComponent-1,testComponent-2", history2.toString()); }
private MutableMessage<?> convertToMutable(Message<?> input) { Object payload = input.getPayload(); if (payload instanceof Tuple && !(payload instanceof MutableTuple)) { payload = TupleBuilder.mutableTuple().putAll((Tuple) payload).build(); } return new MutableMessage<>(payload, input.getHeaders()); }
private MutableMessage<?> convertToMutable(Message<?> input) { Object payload = input.getPayload(); if (payload instanceof Tuple && !(payload instanceof MutableTuple)) { payload = TupleBuilder.mutableTuple().putAll((Tuple) payload).build(); } return new MutableMessage<>(payload, input.getHeaders()); }
@SuppressWarnings("unchecked") public <T> T invoke(ParametersWrapper parameters) throws Exception { Message<?> message = parameters.getMessage(); if (this.canProcessMessageList) { message = new MutableMessage<>(parameters.getMessages(), parameters.getHeaders()); } return (T) this.invocableHandlerMethod.invoke(message); }