Java MessageHeaderAccessor.getMutableAccessor方法代码示例

import org.springframework.messaging.support.MessageHeaderAccessor; //导入方法依赖的package包/类
@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()));
	}

	handleMessageInternal(message, lookupDestination);
	headerAccessor.setImmutable();
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入方法依赖的package包/类
@Override
protected void doSend(String destination, Message<?> message) {
	Assert.notNull(destination, "Destination must not be null");

	SimpMessageHeaderAccessor simpAccessor =
			MessageHeaderAccessor.getAccessor(message, SimpMessageHeaderAccessor.class);

	if (simpAccessor != null) {
		if (simpAccessor.isMutable()) {
			simpAccessor.setDestination(destination);
			simpAccessor.setMessageTypeIfNotSet(SimpMessageType.MESSAGE);
			simpAccessor.setImmutable();
			sendInternal(message);
			return;
		}
		else {
			// Try and keep the original accessor type
			simpAccessor = (SimpMessageHeaderAccessor) MessageHeaderAccessor.getMutableAccessor(message);
			initHeaders(simpAccessor);
		}
	}
	else {
		simpAccessor = SimpMessageHeaderAccessor.wrap(message);
		initHeaders(simpAccessor);
	}

	simpAccessor.setDestination(destination);
	simpAccessor.setMessageTypeIfNotSet(SimpMessageType.MESSAGE);
	message = MessageBuilder.createMessage(message.getPayload(), simpAccessor.getMessageHeaders());
	sendInternal(message);
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入方法依赖的package包/类
@Override
public void inject(Span span, MessageBuilder<?> carrier) {
	Message<?> initialMessage = carrier.build();
	MessageHeaderAccessor accessor = MessageHeaderAccessor
			.getMutableAccessor(initialMessage);
	if (span == null) {
		if (!Span.SPAN_SAMPLED
				.equals(initialMessage.getHeaders().get(Span.SAMPLED_NAME))) {
			accessor.setHeader(Span.SAMPLED_NAME, Span.SPAN_NOT_SAMPLED);
			carrier.setHeaders(accessor);
			return;
		}
		return;
	}
	Map<String, String> headers = new HashMap<>();
	addHeader(headers, Span.TRACE_ID_NAME, Span.idToHex(span.getTraceId()));
	addHeader(headers, Span.SPAN_ID_NAME, Span.idToHex(span.getSpanId()));
	if (span.isExportable()) {
		addAnnotations(this.traceKeys, initialMessage, span);
		Long parentId = getFirst(span.getParents());
		if (parentId != null) {
			addHeader(headers, Span.PARENT_ID_NAME, Span.idToHex(parentId));
		}
		addHeader(headers, Span.SPAN_NAME_NAME, span.getName());
		addHeader(headers, Span.PROCESS_ID_NAME, span.getProcessId());
		addHeader(headers, Span.SAMPLED_NAME, Span.SPAN_SAMPLED);
	}
	else {
		addHeader(headers, Span.SAMPLED_NAME, Span.SPAN_NOT_SAMPLED);
	}
	accessor.setHeader(SPAN_HEADER, span);
	accessor.copyHeaders(headers);
	if (accessor instanceof NativeMessageHeaderAccessor) {
		NativeMessageHeaderAccessor nativeAccessor = (NativeMessageHeaderAccessor) accessor;
		for (String name : headers.keySet()) {
			nativeAccessor.setNativeHeader(name, headers.get(name));
		}
	}
	carrier.setHeaders(accessor);
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入方法依赖的package包/类
@Override
public Message<?> preSend(Message<?> message, MessageChannel channel) {
	if (log.isDebugEnabled()) {
		log.debug("Processing message before sending it to the channel");
	}
	Message<?> retrievedMessage = getMessage(message);
	MessageBuilder<?> messageBuilder = MessageBuilder.fromMessage(retrievedMessage);
	Span parentSpan = getTracer().isTracing() ? getTracer().getCurrentSpan()
			: buildSpan(new MessagingTextMap(messageBuilder));
	// Do not continue the parent (assume that this is handled by caller)
	// getTracer().continueSpan(parentSpan);
	if (log.isDebugEnabled()) {
		log.debug("Parent span is " + parentSpan);
	}
	String name = getMessageChannelName(channel);
	if (log.isDebugEnabled()) {
		log.debug("Name of the span will be [" + name + "]");
	}
	Span span = startSpan(parentSpan, name, message);
	if (message.getHeaders()
			.containsKey(TraceMessageHeaders.MESSAGE_SENT_FROM_CLIENT)) {
		if (log.isDebugEnabled()) {
			log.debug("Marking span with server received");
		}
		span.logEvent(Span.SERVER_RECV);
	}
	else {
		if (log.isDebugEnabled()) {
			log.debug("Marking span with client send");
		}
		span.logEvent(Span.CLIENT_SEND);
		messageBuilder.setHeader(TraceMessageHeaders.MESSAGE_SENT_FROM_CLIENT, true);
	}
	getSpanInjector().inject(span, new MessagingTextMap(messageBuilder));
	MessageHeaderAccessor headers = MessageHeaderAccessor.getMutableAccessor(message);
	if (message instanceof ErrorMessage) {
		headers.copyHeaders(sleuthHeaders(messageBuilder.build().getHeaders()));
		return new ErrorMessage((Throwable) message.getPayload(), headers.getMessageHeaders());
	}
	headers.copyHeaders(messageBuilder.build().getHeaders());
	return new GenericMessage<>(message.getPayload(), headers.getMessageHeaders());
}