Java MessageHeaders类代码示例

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
@PostMapping("/comments")
public Mono<String> addComment(Mono<Comment> newComment) {
	if (commentSink != null) {
		return newComment
			.map(comment -> {
				commentSink.next(MessageBuilder
					.withPayload(comment)
					.setHeader(MessageHeaders.CONTENT_TYPE,
						MediaType.APPLICATION_JSON_VALUE)
					.build());
				return comment;
			})
			.flatMap(comment -> {
				meterRegistry
					.counter("comments.produced", "imageId", comment.getImageId())
					.increment();
				return Mono.just("redirect:/");
			});
	} else {
		return Mono.just("redirect:/");
	}
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
@PreAuthorize("hasRole('USER')")
@PostMapping("/comments")
public Mono<ResponseEntity<?>> addComment(Mono<Comment> newComment) {
	if (commentSink != null) {
		return newComment
			.map(comment -> {
				System.out.println("Got " + comment);
				commentSink.next(MessageBuilder
					.withPayload(comment)
					.setHeader(MessageHeaders.CONTENT_TYPE,
						MediaType.APPLICATION_JSON_VALUE)
					.build());
				return comment;
			})
			.flatMap(comment -> {
				meterRegistry
					.counter("comments.produced", "imageId", comment.getImageId())
					.increment();
				return Mono.just(ResponseEntity.noContent().build());
			});
	} else {
		return Mono.just(ResponseEntity.noContent().build());
	}
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
@PostMapping("/comments")
public Mono<ResponseEntity<?>> addComment(Mono<Comment> newComment) {
	if (commentSink != null) {
		return newComment
			.map(comment -> {
				commentSink.next(MessageBuilder
					.withPayload(comment)
					.setHeader(MessageHeaders.CONTENT_TYPE,
						MediaType.APPLICATION_JSON_VALUE)
					.build());
				return comment;
			})
			.flatMap(comment -> {
				meterRegistry
					.counter("comments.produced", "imageId", comment.getImageId())
					.increment();
				return Mono.just(ResponseEntity.noContent().build());
			});
	} else {
		return Mono.just(ResponseEntity.noContent().build());
	}
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
@Test
public void testSendMessageToEntity() throws Exception {
    entityService.sendMessageToEntity(entity, output);

    verify(simpMessagingTemplate).convertAndSendToUser(
            eq("stompUsername"),
            eq("/queue/output"),
            eq(output),
            messageHeadersArgumentCaptor.capture());

    MessageHeaders headers = messageHeadersArgumentCaptor.getValue();
    SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.getAccessor(headers, SimpMessageHeaderAccessor.class);

    assertEquals("stompSessionId", accessor.getSessionId());
    assertTrue(accessor.isMutable());
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
private void verifyContents() {
    for (int i = 0; i < contents.size(); i++) {
        verify(simpMessagingTemplate).convertAndSendToUser(
                eq("stompUsername" + i),
                eq("/queue/output"),
                eq(output),
                messageHeadersArgumentCaptor.capture()
        );

        MessageHeaders headers = messageHeadersArgumentCaptor.getValue();
        SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.getAccessor(headers, SimpMessageHeaderAccessor.class);

        assertEquals("stompSessionId" + i, accessor.getSessionId());
        assertTrue(accessor.isMutable());
    }
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
/**
 * Authenticate user before he is allowed to connect to
 * the socket.
 *
 * @param message Message<?>
 * @return Principal
 */
private Principal authenticateUser(Message<?> message) {
	MessageHeaders headers = message.getHeaders();
	String token = this.parseToken(headers);

	UserService service = new UserService();
	Traveler user = service.getUserByToken(token);

	if (user.getUid() == null) {
		System.out.println("invalid token");
		return null;
	}

	System.out.println("valid token");
	System.out.println(user.getUid());
	return user;
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
private void receiveMessage(PubsubMessage message, AckReplyConsumer consumer) {
	Map<String, Object> messageHeaders = new HashMap<>();

	message.getAttributesMap().forEach(messageHeaders::put);

	if (this.ackMode == AckMode.MANUAL) {
		// Send the consumer downstream so user decides on when to ack/nack.
		messageHeaders.put(GcpHeaders.ACKNOWLEDGEMENT, consumer);
	}

	try {
		sendMessage(this.messageConverter.toMessage(
				message.getData().toStringUtf8(),
				new MessageHeaders(messageHeaders)));
	}
	catch (RuntimeException re) {
		if (this.ackMode == AckMode.AUTO) {
			consumer.nack();
		}
		throw re;
	}

	if (this.ackMode == AckMode.AUTO) {
		consumer.ack();
	}
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
@Test
public void testWorkDelegatesMethodCall() throws Exception {
    // given
    AtomicInteger counter = new AtomicInteger(0);
    MessageWorker<String, Integer> uut = new MessageWorker<String, Integer>() {
        @Override
        public Integer work(String object) {
            return counter.incrementAndGet();
        }
    };
    MessageHeaders messageHeaders = mock(MessageHeaders.class);

    // when
    uut.work("dummy value", messageHeaders);

    // then
    assertEquals(1, counter.intValue());
    verifyZeroInteractions(messageHeaders);
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
@Override
protected boolean canConvertTo(Object payload, MessageHeaders headers) {
	if (!jackson23Available || !logger.isWarnEnabled()) {
		return (this.objectMapper.canSerialize(payload.getClass()) && supportsMimeType(headers));
	}
	AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
	if (this.objectMapper.canSerialize(payload.getClass(), causeRef) && supportsMimeType(headers)) {
		return true;
	}
	Throwable cause = causeRef.get();
	if (cause != null) {
		String msg = "Failed to evaluate serialization for type [" + payload.getClass() + "]";
		if (logger.isDebugEnabled()) {
			logger.warn(msg, cause);
		}
		else {
			logger.warn(msg + ": " + cause);
		}
	}
	return false;
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
@Override
public MimeType resolve(MessageHeaders headers) {
	if (headers == null || headers.get(MessageHeaders.CONTENT_TYPE) == null) {
		return this.defaultMimeType;
	}
	Object value = headers.get(MessageHeaders.CONTENT_TYPE);
	if (value instanceof MimeType) {
		return (MimeType) value;
	}
	else if (value instanceof String) {
		return MimeType.valueOf((String) value);
	}
	else {
		throw new IllegalArgumentException(
				"Unknown type for contentType header value: " + value.getClass());
	}
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
@Before
public void setup() throws Exception {
	this.resolver = new HeadersMethodArgumentResolver();

	Method method = getClass().getDeclaredMethod("handleMessage", Map.class, String.class,
			MessageHeaders.class, MessageHeaderAccessor.class, TestMessageHeaderAccessor.class);

	this.paramAnnotated = new MethodParameter(method, 0);
	this.paramAnnotatedNotMap = new MethodParameter(method, 1);
	this.paramMessageHeaders = new MethodParameter(method, 2);
	this.paramMessageHeaderAccessor = new MethodParameter(method, 3);
	this.paramMessageHeaderAccessorSubclass = new MethodParameter(method, 4);

	Map<String, Object> headers = new HashMap<String, Object>();
	headers.put("foo", "bar");
	this.message = MessageBuilder.withPayload(new byte[0]).copyHeaders(headers).build();
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
@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"));
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
private void sendSystemSubscriptions() {
	int i = 0;
	for (String destination : getSystemSubscriptions().keySet()) {
		StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.SUBSCRIBE);
		accessor.setSubscriptionId(String.valueOf(i++));
		accessor.setDestination(destination);
		if (logger.isDebugEnabled()) {
			logger.debug("Subscribing to " + destination + " on \"system\" connection.");
		}
		TcpConnection<byte[]> conn = getTcpConnection();
		if (conn != null) {
			MessageHeaders headers = accessor.getMessageHeaders();
			conn.send(MessageBuilder.createMessage(EMPTY_PAYLOAD, headers)).addCallback(
					new ListenableFutureCallback<Void>() {
						public void onSuccess(Void result) {
						}
						public void onFailure(Throwable ex) {
							String error = "Failed to subscribe in \"system\" session.";
							handleTcpConnectionFailure(error, ex);
						}
					});
		}
	}
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
@Test
public void testHeadersToSend() throws Exception {
	Message<?> inputMessage = createInputMessage("sess1", "sub1", "/app", "/dest", null);

	SimpMessageSendingOperations messagingTemplate = Mockito.mock(SimpMessageSendingOperations.class);
	SendToMethodReturnValueHandler handler = new SendToMethodReturnValueHandler(messagingTemplate, false);

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

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

	MessageHeaders messageHeaders = captor.getValue();
	SimpMessageHeaderAccessor accessor = getAccessor(messageHeaders, SimpMessageHeaderAccessor.class);
	assertNotNull(accessor);
	assertTrue(accessor.isMutable());
	assertEquals("sess1", accessor.getSessionId());
	assertNull("Subscription id should not be copied", accessor.getSubscriptionId());
	assertEquals(this.noAnnotationsReturnType, accessor.getHeader(SimpMessagingTemplate.CONVERSION_HINT_HEADER));
}
 

import org.springframework.messaging.MessageHeaders; //导入依赖的package包/类
@Override
public final void unregisterSubscription(Message<?> message) {
	MessageHeaders headers = message.getHeaders();

	SimpMessageType messageType = SimpMessageHeaderAccessor.getMessageType(headers);
	if (!SimpMessageType.UNSUBSCRIBE.equals(messageType)) {
		throw new IllegalArgumentException("Expected UNSUBSCRIBE: " + message);
	}

	String sessionId = SimpMessageHeaderAccessor.getSessionId(headers);
	if (sessionId == null) {
		logger.error("No sessionId in " + message);
		return;
	}

	String subscriptionId = SimpMessageHeaderAccessor.getSubscriptionId(headers);
	if (subscriptionId == null) {
		logger.error("No subscriptionId " + message);
		return;
	}

	removeSubscriptionInternal(sessionId, subscriptionId, message);
}