public void setErrorChannel(MessageChannel errorChannel) { setHeader(MessageHeaders.ERROR_CHANNEL, errorChannel); }
public void setReplyChannelName(String replyChannelName) { setHeader(MessageHeaders.REPLY_CHANNEL, replyChannelName); }
public void setReplyChannel(MessageChannel replyChannel) { setHeader(MessageHeaders.REPLY_CHANNEL, replyChannel); }
public void setContentType(MimeType contentType) { setHeader(MessageHeaders.CONTENT_TYPE, contentType); }
public void setErrorChannelName(String errorChannelName) { setHeader(MessageHeaders.ERROR_CHANNEL, errorChannelName); }
/** * Set the value for the given header name. If the provided value is {@code null}, * the header will be removed. */ public MessageBuilder<T> setHeader(String headerName, @Nullable Object headerValue) { this.headerAccessor.setHeader(headerName, headerValue); return this; }
/** * Remove the value for the given header name. */ public void removeHeader(String headerName) { if (StringUtils.hasLength(headerName) && !isReadOnly(headerName)) { setHeader(headerName, null); } }
/** * Set the value for the given header name only if the header name is not * already associated with a value. */ public void setHeaderIfAbsent(String name, Object value) { if (getHeader(name) == null) { setHeader(name, value); } }
/** * Copy the name-value pairs from the provided Map. * <p>This operation will overwrite any existing values. Use * {@link #copyHeadersIfAbsent(Map)} to avoid overwriting values. */ public void copyHeaders(@Nullable Map<String, ?> headersToCopy) { if (headersToCopy != null) { headersToCopy.forEach((key, value) -> { if (!isReadOnly(key)) { setHeader(key, value); } }); } }
@Override protected void handleMatch(SimpMessageMappingInfo mapping, HandlerMethod handlerMethod, String lookupDestination, Message<?> message) { Set<String> patterns = mapping.getDestinationConditions().getPatterns(); if (!CollectionUtils.isEmpty(patterns)) { String pattern = patterns.iterator().next(); Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(pattern, lookupDestination); if (!CollectionUtils.isEmpty(vars)) { MessageHeaderAccessor mha = MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class); Assert.state(mha != null && mha.isMutable(), "Mutable MessageHeaderAccessor required"); mha.setHeader(DestinationVariableMethodArgumentResolver.DESTINATION_TEMPLATE_VARIABLES_HEADER, vars); } } try { SimpAttributesContextHolder.setAttributesFromMessage(message); super.handleMatch(mapping, handlerMethod, lookupDestination, message); } finally { SimpAttributesContextHolder.resetAttributes(); } }
@Test public void toMap() { MessageHeaderAccessor accessor = new MessageHeaderAccessor(); accessor.setHeader("foo", "bar1"); Map<String, Object> map1 = accessor.toMap(); accessor.setHeader("foo", "bar2"); Map<String, Object> map2 = accessor.toMap(); accessor.setHeader("foo", "bar3"); Map<String, Object> map3 = accessor.toMap(); assertEquals(1, map1.size()); assertEquals(1, map2.size()); assertEquals(1, map3.size()); assertEquals("bar1", map1.get("foo")); assertEquals("bar2", map2.get("foo")); assertEquals("bar3", map3.get("foo")); }
@Test public void testBuildMultipleMessages() { MessageHeaderAccessor headerAccessor = new MessageHeaderAccessor(); MessageBuilder<?> messageBuilder = MessageBuilder.withPayload("payload").setHeaders(headerAccessor); headerAccessor.setHeader("foo", "bar1"); Message<?> message1 = messageBuilder.build(); headerAccessor.setHeader("foo", "bar2"); Message<?> message2 = messageBuilder.build(); headerAccessor.setHeader("foo", "bar3"); Message<?> message3 = messageBuilder.build(); assertEquals("bar1", message1.getHeaders().get("foo")); assertEquals("bar2", message2.getHeaders().get("foo")); assertEquals("bar3", message3.getHeaders().get("foo")); } }
@Test public void toMessageWithPayloadAndMutableHeaders() { MessageHeaderAccessor accessor = new MessageHeaderAccessor(); accessor.setHeader("foo", "bar"); accessor.setLeaveMutable(true); MessageHeaders headers = accessor.getMessageHeaders(); Message<?> message = this.converter.toMessage("payload", headers); assertEquals("payload", message.getPayload()); assertSame(headers, message.getHeaders()); assertEquals("bar", message.getHeaders().get("foo")); } }
@Test public void leaveMutable() { MessageHeaderAccessor accessor = new MessageHeaderAccessor(); accessor.setHeader("foo", "bar"); accessor.setLeaveMutable(true); MessageHeaders headers = accessor.getMessageHeaders(); Message<?> message = MessageBuilder.createMessage("payload", headers); accessor.setHeader("foo", "baz"); assertEquals("baz", headers.get("foo")); assertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class)); }
@Test public void convertAndSendWithSimpMessageHeaders() { MessageHeaderAccessor accessor = new MessageHeaderAccessor(); accessor.setHeader("key", "value"); accessor.setLeaveMutable(true); MessageHeaders headers = accessor.getMessageHeaders(); this.template.convertAndSend("channel", "data", headers); List<Message<byte[]>> messages = this.messageChannel.getMessages(); Message<byte[]> message = messages.get(0); assertSame(headers, message.getHeaders()); assertFalse(accessor.isMutable()); }
@Test public void existingHeadersModification() throws InterruptedException { Map<String, Object> map = new HashMap<>(); map.put("foo", "bar"); map.put("bar", "baz"); GenericMessage<String> message = new GenericMessage<>("payload", map); Thread.sleep(50); MessageHeaderAccessor accessor = new MessageHeaderAccessor(message); accessor.setHeader("foo", "BAR"); MessageHeaders actual = accessor.getMessageHeaders(); assertEquals(3, actual.size()); assertNotEquals(message.getHeaders().getId(), actual.getId()); assertEquals("BAR", actual.get("foo")); assertEquals("baz", actual.get("bar")); }
@Test public void leaveMutableDefaultBehavior() { MessageHeaderAccessor accessor = new MessageHeaderAccessor(); accessor.setHeader("foo", "bar"); MessageHeaders headers = accessor.getMessageHeaders(); Message<?> message = MessageBuilder.createMessage("payload", headers); this.thrown.expect(IllegalStateException.class); this.thrown.expectMessage("Already immutable"); accessor.setLeaveMutable(true); this.thrown.expect(IllegalStateException.class); this.thrown.expectMessage("Already immutable"); accessor.setHeader("foo", "baz"); assertEquals("bar", headers.get("foo")); assertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class)); }
@Test public void testBuildMessageWithDefaultMutability() { MessageHeaderAccessor accessor = new MessageHeaderAccessor(); MessageHeaders headers = accessor.getMessageHeaders(); Message<?> message = MessageBuilder.createMessage("foo", headers); this.thrown.expect(IllegalStateException.class); this.thrown.expectMessage("Already immutable"); accessor.setHeader("foo", "bar"); assertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class)); }
@Test public void testBuildMessageWithMutableHeaders() { MessageHeaderAccessor accessor = new MessageHeaderAccessor(); accessor.setLeaveMutable(true); MessageHeaders headers = accessor.getMessageHeaders(); Message<?> message = MessageBuilder.createMessage("payload", headers); accessor.setHeader("foo", "bar"); assertEquals("bar", headers.get("foo")); assertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class)); }
@Test public void convertAndSendPayloadAndMutableHeadersToDestination() { MessageHeaderAccessor accessor = new MessageHeaderAccessor(); accessor.setHeader("foo", "bar"); accessor.setLeaveMutable(true); MessageHeaders messageHeaders = accessor.getMessageHeaders(); this.template.setMessageConverter(new StringMessageConverter()); this.template.convertAndSend("somewhere", "payload", messageHeaders); MessageHeaders actual = this.template.message.getHeaders(); assertSame(messageHeaders, actual); assertEquals(new MimeType("text", "plain", StandardCharsets.UTF_8), actual.get(MessageHeaders.CONTENT_TYPE)); assertEquals("bar", actual.get("foo")); }