/** * Return the underlying {@code MessageHeaders} instance. * <p>Unless {@link #setLeaveMutable(boolean)} was set to {@code true}, after * this call, the headers are immutable and this accessor can no longer * modify them. * <p>This method always returns the same {@code MessageHeaders} instance if * invoked multiples times. To obtain a copy of the underlying headers, use * {@link #toMessageHeaders()} or {@link #toMap()} instead. * @since 4.1 */ public MessageHeaders getMessageHeaders() { if (!this.leaveMutable) { setImmutable(); } return this.headers; }
@Override public Message<?> preSend(Message<?> message, MessageChannel channel) { MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class); if (accessor != null && accessor.isMutable()) { accessor.setImmutable(); } return message; }
@Override public void setImmutable() { if (isMutable()) { Map<String, List<String>> map = getNativeHeaders(); if (map != null) { // Force removal since setHeader checks for equality removeHeader(NATIVE_HEADERS); setHeader(NATIVE_HEADERS, Collections.unmodifiableMap(map)); } super.setImmutable(); } }
protected final void doSend(MessageChannel channel, Message<?> message, long timeout) { Assert.notNull(channel, "MessageChannel is required"); Message<?> messageToSend = message; MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class); if (accessor != null && accessor.isMutable()) { accessor.removeHeader(this.sendTimeoutHeader); accessor.removeHeader(this.receiveTimeoutHeader); accessor.setImmutable(); } else if (message.getHeaders().containsKey(this.sendTimeoutHeader) || message.getHeaders().containsKey(this.receiveTimeoutHeader)) { messageToSend = MessageBuilder.fromMessage(message) .setHeader(this.sendTimeoutHeader, null) .setHeader(this.receiveTimeoutHeader, null) .build(); } boolean sent = (timeout >= 0 ? channel.send(messageToSend, timeout) : channel.send(messageToSend)); if (!sent) { throw new MessageDeliveryException(message, "Failed to send message to channel '" + channel + "' within timeout: " + timeout); } }
@Override public void handleMessage(Message<?> message) throws MessagingException { String destination = getDestination(message); if (destination == null) { return; } String lookupDestination = getLookupDestination(destination); if (lookupDestination == null) { return; } MessageHeaderAccessor headerAccessor = MessageHeaderAccessor.getMutableAccessor(message); headerAccessor.setHeader(DestinationPatternsMessageCondition.LOOKUP_DESTINATION_HEADER, lookupDestination); headerAccessor.setLeaveMutable(true); message = MessageBuilder.createMessage(message.getPayload(), headerAccessor.getMessageHeaders()); if (logger.isDebugEnabled()) { logger.debug("Searching methods to handle " + headerAccessor.getShortLogMessage(message.getPayload()) + ", lookupDestination='" + lookupDestination + "'"); } handleMessageInternal(message, lookupDestination); headerAccessor.setImmutable(); }
/** * Use this to create a span for processing the given message. Note: the result has no * name and is not started. * <p> * <p> * This creates a child from identifiers extracted from the message headers, or a new * span if one couldn't be extracted. */ public Span nextSpan(Message<?> message) { MessageHeaderAccessor headers = mutableHeaderAccessor(message); TraceContextOrSamplingFlags extracted = this.extractor.extract(headers); headers.setImmutable(); Span result = this.tracer.nextSpan(extracted); if (extracted.context() == null && !result.isNoop()) { addTags(message, result, null); } if (log.isDebugEnabled()) { log.debug("Created a new span " + result); } return result; }
/** * This starts a consumer span as a child of the incoming message or the current trace * context, placing it in scope until the receive completes. */ @Override public Message<?> postReceive(Message<?> message, MessageChannel channel) { if (emptyMessage(message)) { return message; } MessageHeaderAccessor headers = mutableHeaderAccessor(message); TraceContextOrSamplingFlags extracted = this.extractor.extract(headers); Span span = this.threadLocalSpan.next(extracted); MessageHeaderPropagation.removeAnyTraceHeaders(headers, this.tracing.propagation().keys()); this.injector.inject(span.context(), headers); if (!span.isNoop()) { span.kind(Span.Kind.CONSUMER).name("receive").start(); span.remoteServiceName(REMOTE_SERVICE_NAME); addTags(message, span, channel); } if (log.isDebugEnabled()) { log.debug("Created a new span in post receive " + span); } headers.setImmutable(); return new GenericMessage<>(message.getPayload(), headers.getMessageHeaders()); }
/** * Return the underlying {@code MessageHeaders} instance. * <p>Unless {@link #setLeaveMutable(boolean)} was set to {@code true}, after * this call, the headers are immutable and this accessor can no longer * modify them. * <p>This method always returns the same {@code MessageHeaders} instance if * invoked multiples times. To obtain a copy of the underlying headers, use * {@link #toMessageHeaders()} or {@link #toMap()} instead. * @since 4.1 */ public MessageHeaders getMessageHeaders() { if (!this.leaveMutable) { setImmutable(); } return this.headers; }
headers.getMessageHeaders()); headers.setImmutable(); return new GenericMessage<>(message.getPayload(), headers.getMessageHeaders());
@Test public void idTimestampWithMutableHeaders() { MessageHeaderAccessor accessor = new MessageHeaderAccessor(); accessor.setIdGenerator(() -> MessageHeaders.ID_VALUE_NONE); accessor.setEnableTimestamp(false); accessor.setLeaveMutable(true); MessageHeaders headers = accessor.getMessageHeaders(); assertNull(headers.getId()); assertNull(headers.getTimestamp()); final UUID id = new UUID(0L, 23L); accessor.setIdGenerator(() -> id); accessor.setEnableTimestamp(true); accessor.setImmutable(); assertSame(id, accessor.getMessageHeaders().getId()); assertNotNull(headers.getTimestamp()); }
@Override public Message<?> preSend(Message<?> message, MessageChannel channel) { MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class); if (accessor != null && accessor.isMutable()) { accessor.setImmutable(); } return message; }
@Override public void setImmutable() { if (isMutable()) { Map<String, List<String>> map = getNativeHeaders(); if (map != null) { // Force removal since setHeader checks for equality removeHeader(NATIVE_HEADERS); setHeader(NATIVE_HEADERS, Collections.unmodifiableMap(map)); } super.setImmutable(); } }
@Override public void handleMessage(Message<?> message) throws MessagingException { String destination = getDestination(message); if (destination == null) { return; } String lookupDestination = getLookupDestination(destination); if (lookupDestination == null) { return; } MessageHeaderAccessor headerAccessor = MessageHeaderAccessor.getMutableAccessor(message); headerAccessor.setHeader(DestinationPatternsMessageCondition.LOOKUP_DESTINATION_HEADER, lookupDestination); headerAccessor.setLeaveMutable(true); message = MessageBuilder.createMessage(message.getPayload(), headerAccessor.getMessageHeaders()); if (logger.isDebugEnabled()) { logger.debug("Searching methods to handle " + headerAccessor.getShortLogMessage(message.getPayload()) + ", lookupDestination='" + lookupDestination + "'"); } handleMessageInternal(message, lookupDestination); headerAccessor.setImmutable(); }
protected final void doSend(MessageChannel channel, Message<?> message, long timeout) { Assert.notNull(channel, "MessageChannel is required"); Message<?> messageToSend = message; MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class); if (accessor != null && accessor.isMutable()) { accessor.removeHeader(this.sendTimeoutHeader); accessor.removeHeader(this.receiveTimeoutHeader); accessor.setImmutable(); } else if (message.getHeaders().containsKey(this.sendTimeoutHeader) || message.getHeaders().containsKey(this.receiveTimeoutHeader)) { messageToSend = MessageBuilder.fromMessage(message) .setHeader(this.sendTimeoutHeader, null) .setHeader(this.receiveTimeoutHeader, null) .build(); } boolean sent = (timeout >= 0 ? channel.send(messageToSend, timeout) : channel.send(messageToSend)); if (!sent) { throw new MessageDeliveryException(message, "Failed to send message to channel '" + channel + "' within timeout: " + timeout); } }
/** * Return the underlying {@code MessageHeaders} instance. * <p>Unless {@link #setLeaveMutable(boolean)} was set to {@code true}, after * this call, the headers are immutable and this accessor can no longer * modify them. * <p>This method always returns the same {@code MessageHeaders} instance if * invoked multiples times. To obtain a copy of the underlying headers, use * {@link #toMessageHeaders()} or {@link #toMap()} instead. * @since 4.1 */ public MessageHeaders getMessageHeaders() { if (!this.leaveMutable) { setImmutable(); } return this.headers; }
/** * Return the underlying {@code MessageHeaders} instance. * <p>Unless {@link #setLeaveMutable(boolean)} was set to {@code true}, after * this call, the headers are immutable and this accessor can no longer * modify them. * <p>This method always returns the same {@code MessageHeaders} instance if * invoked multiples times. To obtain a copy of the underlying headers, use * {@link #toMessageHeaders()} or {@link #toMap()} instead. * @since 4.1 */ public MessageHeaders getMessageHeaders() { if (!this.leaveMutable) { setImmutable(); } return this.headers; }
@Override public Message<?> preSend(Message<?> message, MessageChannel channel) { MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class); if (accessor != null && accessor.isMutable()) { accessor.setImmutable(); } return message; }
@Override public Message<?> preSend(Message<?> message, MessageChannel channel) { MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class); if (accessor != null && accessor.isMutable()) { accessor.setImmutable(); } return message; }
@Override public void setImmutable() { if (isMutable()) { Map<String, List<String>> map = getNativeHeaders(); if (map != null) { // Force removal since setHeader checks for equality removeHeader(NATIVE_HEADERS); setHeader(NATIVE_HEADERS, Collections.unmodifiableMap(map)); } super.setImmutable(); } }
@Override public void setImmutable() { if (isMutable()) { Map<String, List<String>> map = getNativeHeaders(); if (map != null) { // Force removal since setHeader checks for equality removeHeader(NATIVE_HEADERS); setHeader(NATIVE_HEADERS, Collections.unmodifiableMap(map)); } super.setImmutable(); } }