Java MessageHeaderAccessor类代码示例

import org.springframework.messaging.support.MessageHeaderAccessor; //导入依赖的package包/类
@Override
public Message<?> preSend(final Message<?> message, final MessageChannel channel) throws AuthenticationException {
    final StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);

    if (StompCommand.CONNECT == accessor.getCommand()) {
        final String username = accessor.getFirstNativeHeader(USERNAME_HEADER);
        final String authToken = accessor.getFirstNativeHeader(TOKEN_HEADER);

        final Authentication user = webSocketAuthenticatorService.getAuthenticatedOrFail(username, authToken);

        accessor.setUser(user);
    }

    return message;
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入依赖的package包/类
@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());
			mha.setHeader(DestinationVariableMethodArgumentResolver.DESTINATION_TEMPLATE_VARIABLES_HEADER, vars);
		}
	}

	try {
		SimpAttributesContextHolder.setAttributesFromMessage(message);
		super.handleMatch(mapping, handlerMethod, lookupDestination, message);
	}
	finally {
		SimpAttributesContextHolder.resetAttributes();
	}
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入依赖的package包/类
@Override
public void handleMessage(Message<byte[]> message) {
	StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
	accessor.setSessionId(this.sessionId);
	accessor.setUser(this.connectHeaders.getUser());

	StompCommand command = accessor.getCommand();
	if (StompCommand.CONNECTED.equals(command)) {
		if (logger.isDebugEnabled()) {
			logger.debug("Received " + accessor.getShortLogMessage(EMPTY_PAYLOAD));
		}
		afterStompConnected(accessor);
	}
	else if (logger.isErrorEnabled() && StompCommand.ERROR.equals(command)) {
		logger.error("Received " + accessor.getShortLogMessage(message.getPayload()));
	}
	else if (logger.isTraceEnabled()) {
		logger.trace("Received " + accessor.getDetailedLogMessage(message.getPayload()));
	}

	handleInboundMessage(message);
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入依赖的package包/类
@Override
public TypedValue read(EvaluationContext context, Object target, String name) throws AccessException {
	MessageHeaders headers = (MessageHeaders) target;
	SimpMessageHeaderAccessor accessor =
			MessageHeaderAccessor.getAccessor(headers, SimpMessageHeaderAccessor.class);
	Object value;
	if ("destination".equalsIgnoreCase(name)) {
		value = accessor.getDestination();
	}
	else {
		value = accessor.getFirstNativeHeader(name);
		if (value == null) {
			value = headers.get(name);
		}
	}
	return new TypedValue(value);
}
 

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 final void doSend(MessageChannel channel, Message<?> message) {
	Assert.notNull(channel, "'channel' is required");

	MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class);
	if (accessor != null && accessor.isMutable()) {
		accessor.setImmutable();
	}

	long timeout = this.sendTimeout;
	boolean sent = (timeout >= 0 ? channel.send(message, timeout) : channel.send(message));

	if (!sent) {
		throw new MessageDeliveryException(message,
				"failed to send message to channel '" + channel + "' within timeout: " + timeout);
	}
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入依赖的package包/类
@Test
@SuppressWarnings({ "unchecked", "rawtypes" })
public void testHeadersPassedToMessagingTemplate() throws Exception {
	String sessionId = "sess1";
	String subscriptionId = "subs1";
	String destination = "/dest";
	Message<?> inputMessage = createInputMessage(sessionId, subscriptionId, destination, null);

	MessageSendingOperations messagingTemplate = Mockito.mock(MessageSendingOperations.class);
	SubscriptionMethodReturnValueHandler handler = new SubscriptionMethodReturnValueHandler(messagingTemplate);

	handler.handleReturnValue(PAYLOAD, this.subscribeEventReturnType, inputMessage);

	ArgumentCaptor<MessageHeaders> captor = ArgumentCaptor.forClass(MessageHeaders.class);
	verify(messagingTemplate).convertAndSend(eq("/dest"), eq(PAYLOAD), captor.capture());

	SimpMessageHeaderAccessor headerAccessor =
			MessageHeaderAccessor.getAccessor(captor.getValue(), SimpMessageHeaderAccessor.class);

	assertNotNull(headerAccessor);
	assertTrue(headerAccessor.isMutable());
	assertEquals(sessionId, headerAccessor.getSessionId());
	assertEquals(subscriptionId, headerAccessor.getSubscriptionId());
	assertEquals(this.subscribeEventReturnType, headerAccessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER));
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入依赖的package包/类
@Test
public void afterConnected() throws Exception {

	assertFalse(this.session.isConnected());
	this.connectHeaders.setHost("my-host");
	this.connectHeaders.setHeartbeat(new long[] {11, 12});

	this.session.afterConnected(this.connection);
	assertTrue(this.session.isConnected());

	Message<byte[]> message = this.messageCaptor.getValue();
	StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
	assertEquals(StompCommand.CONNECT, accessor.getCommand());
	assertEquals("my-host", accessor.getHost());
	assertThat(accessor.getAcceptVersion(), containsInAnyOrder("1.1", "1.2"));
	assertArrayEquals(new long[] {11, 12}, accessor.getHeartbeat());
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入依赖的package包/类
@Test
public void send() throws Exception {

	this.session.afterConnected(this.connection);
	assertTrue(this.session.isConnected());

	String destination = "/topic/foo";
	String payload = "sample payload";
	this.session.send(destination, payload);

	Message<byte[]> message = this.messageCaptor.getValue();
	StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
	assertEquals(StompCommand.SEND, accessor.getCommand());

	StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
	assertEquals(stompHeaders.toString(), 2, stompHeaders.size());

	assertEquals(destination, stompHeaders.getDestination());
	assertEquals(new MimeType("text", "plain", UTF_8), stompHeaders.getContentType());
	assertEquals(-1, stompHeaders.getContentLength()); // StompEncoder isn't involved
	assertEquals(payload, new String(message.getPayload(), UTF_8));
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入依赖的package包/类
@Test
public void sendWithReceipt() throws Exception {

	this.session.afterConnected(this.connection);
	assertTrue(this.session.isConnected());

	this.session.setTaskScheduler(mock(TaskScheduler.class));
	this.session.setAutoReceipt(true);
	this.session.send("/topic/foo", "sample payload");

	Message<byte[]> message = this.messageCaptor.getValue();
	StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
	assertNotNull(accessor.getReceipt());

	StompHeaders stompHeaders = new StompHeaders();
	stompHeaders.setDestination("/topic/foo");
	stompHeaders.setReceipt("my-receipt");
	this.session.send(stompHeaders, "sample payload");

	message = this.messageCaptor.getValue();
	accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
	assertEquals("my-receipt", accessor.getReceipt());
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入依赖的package包/类
@Test
public void subscribe() throws Exception {

	this.session.afterConnected(this.connection);
	assertTrue(this.session.isConnected());

	String destination = "/topic/foo";
	StompFrameHandler frameHandler = mock(StompFrameHandler.class);
	Subscription subscription = this.session.subscribe(destination, frameHandler);

	Message<byte[]> message = this.messageCaptor.getValue();
	StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
	assertEquals(StompCommand.SUBSCRIBE, accessor.getCommand());

	StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
	assertEquals(stompHeaders.toString(), 2, stompHeaders.size());
	assertEquals(destination, stompHeaders.getDestination());
	assertEquals(subscription.getSubscriptionId(), stompHeaders.getId());
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入依赖的package包/类
@Test
public void subscribeWithHeaders() throws Exception {

	this.session.afterConnected(this.connection);
	assertTrue(this.session.isConnected());

	String subscriptionId = "123";
	String destination = "/topic/foo";

	StompHeaders stompHeaders = new StompHeaders();
	stompHeaders.setId(subscriptionId);
	stompHeaders.setDestination(destination);
	StompFrameHandler frameHandler = mock(StompFrameHandler.class);

	Subscription subscription = this.session.subscribe(stompHeaders, frameHandler);
	assertEquals(subscriptionId, subscription.getSubscriptionId());

	Message<byte[]> message = this.messageCaptor.getValue();
	StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
	assertEquals(StompCommand.SUBSCRIBE, accessor.getCommand());

	stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
	assertEquals(stompHeaders.toString(), 2, stompHeaders.size());
	assertEquals(destination, stompHeaders.getDestination());
	assertEquals(subscriptionId, stompHeaders.getId());
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入依赖的package包/类
@Test
public void unsubscribe() throws Exception {

	this.session.afterConnected(this.connection);
	assertTrue(this.session.isConnected());

	String destination = "/topic/foo";
	StompFrameHandler frameHandler = mock(StompFrameHandler.class);
	Subscription subscription = this.session.subscribe(destination, frameHandler);
	subscription.unsubscribe();

	Message<byte[]> message = this.messageCaptor.getValue();
	StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
	assertEquals(StompCommand.UNSUBSCRIBE, accessor.getCommand());

	StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders());
	assertEquals(stompHeaders.toString(), 1, stompHeaders.size());
	assertEquals(subscription.getSubscriptionId(), stompHeaders.getId());
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入依赖的package包/类
@Test
public void convertAndSendWithCustomHeaderNonNative() {
	Map<String, Object> headers = new HashMap<>();
	headers.put("key", "value");
	headers.put(NativeMessageHeaderAccessor.NATIVE_HEADERS, new LinkedMultiValueMap<String, String>());
	this.messagingTemplate.convertAndSend("/foo", "data", headers);

	List<Message<byte[]>> messages = this.messageChannel.getMessages();

	SimpMessageHeaderAccessor headerAccessor =
			MessageHeaderAccessor.getAccessor(messages.get(0), SimpMessageHeaderAccessor.class);

	assertNotNull(headerAccessor);
	assertEquals("value", headerAccessor.toMap().get("key"));
	assertNull(headerAccessor.getNativeHeader("key"));
}
 

import org.springframework.messaging.support.MessageHeaderAccessor; //导入依赖的package包/类
@Test
public void convertAndSendWithCustomDestinationPrefix() {
	this.messagingTemplate.setUserDestinationPrefix("/prefix");
	this.messagingTemplate.convertAndSendToUser("joe", "/queue/foo", "data");
	List<Message<byte[]>> messages = this.messageChannel.getMessages();

	assertEquals(1, messages.size());

	Message<byte[]> message = messages.get(0);
	SimpMessageHeaderAccessor headerAccessor =
			MessageHeaderAccessor.getAccessor(message, SimpMessageHeaderAccessor.class);

	assertNotNull(headerAccessor);
	assertEquals(SimpMessageType.MESSAGE, headerAccessor.getMessageType());
	assertEquals("/prefix/joe/queue/foo", headerAccessor.getDestination());
}