Java MessageBuilder类代码示例

import org.springframework.messaging.support.MessageBuilder; //导入依赖的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.support.MessageBuilder; //导入依赖的package包/类
@PostMapping("/stack-events")
public ResponseEntity<String> event(@RequestBody String payload) {
    try {
        String result = java.net.URLDecoder.decode(payload, "UTF-8");
        ObjectMapper objectMapper = new ObjectMapper();

        StackEvent stackEvent = objectMapper.readValue(result, StackEvent.class);
        stackEvent.setUserToken(authenticationService.getCurrentToken());

        payload = jsonTransformService.write(stackEvent);

        this.queueMessagingTemplate.send(queue,
                MessageBuilder.withPayload(payload).build());
    } catch (IOException e) {
        log.error(e.getLocalizedMessage());
    }

    return new ResponseEntity<>(HttpStatus.NO_CONTENT);
}
 

import org.springframework.messaging.support.MessageBuilder; //导入依赖的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.support.MessageBuilder; //导入依赖的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.support.MessageBuilder; //导入依赖的package包/类
@PostMapping("/")
public RedirectView startCreditApplicationProcess() {
	//Create Credit Application Number
	UUID creditApplicationNumber = UUID.randomUUID();
	Date applicationTime = new Date();
	LOGGER.info("Created a new Credit Application Number: " + creditApplicationNumber.toString());

	// We are saving the initial status
	CreditApplicationStatus status = new CreditApplicationStatus(creditApplicationNumber.toString(), applicationTime);
	repository.save(status);
	LOGGER.info("Saved " + status.toString());

	// We are sending a CreditApplicationNumberGeneratedEvent
	CreditApplicationNumberGeneratedEvent event = new CreditApplicationNumberGeneratedEvent();
	event.setApplicationNumber(creditApplicationNumber.toString());
	event.setCreationTime(applicationTime);
	applicationProcessChannels.creditApplicationNumberGeneratedOut()
			.send(MessageBuilder.withPayload(event).build());
	LOGGER.info("Sent " + event.toString());

	return new RedirectView(nextProcessStepUrl + creditApplicationNumber.toString());
}
 

import org.springframework.messaging.support.MessageBuilder; //导入依赖的package包/类
@RequestMapping(path = "/users/{userId}/commands/addFriend", method = RequestMethod.POST)
public HttpEntity<?> addFriend(@PathVariable Long userId, @RequestParam("friendId") Long friendId) {
    Friend friend;

    // Check if friend relationship already exists
    if (!friendRepository.existsByUserIdAndFriendId(userId, friendId)) {
        friend = new Friend(userId, friendId);

        // Save friend relationship
        friendRepository.save(friend);

        // Broadcast a new domain event
        eventStream.output().send(MessageBuilder
                .withPayload(new FriendEvent(friend, EventType.FRIEND_ADDED)).build());
    } else {
        return new ResponseEntity<>(HttpStatus.CONFLICT);
    }

    return new ResponseEntity<>(friend, HttpStatus.CREATED);
}
 

import org.springframework.messaging.support.MessageBuilder; //导入依赖的package包/类
@RequestMapping(path = "/users/{userId}/commands/removeFriend", method = RequestMethod.PUT)
public HttpEntity<?> removeFriend(@PathVariable Long userId, @RequestParam("friendId") Long friendId) {

    // Fetch friend relationship
    Friend friend = friendRepository.findFriendByUserIdAndFriendId(userId, friendId);

    if (friend != null) {
        // Delete friend relationship
        friendRepository.delete(friend);

        // Broadcast a new domain event
        eventStream.output().send(MessageBuilder
                .withPayload(new FriendEvent(friend, EventType.FRIEND_REMOVED)).build());
    } else {
        return new ResponseEntity<>(HttpStatus.NOT_FOUND);
    }

    return new ResponseEntity<>(HttpStatus.NO_CONTENT);
}
 

import org.springframework.messaging.support.MessageBuilder; //导入依赖的package包/类
@PostMapping("/teams")
public ResponseEntity<String> post(@RequestBody String payload) {
    log.info(new GsonBuilder().setPrettyPrinting().create().toJson(new JsonParser().parse(payload)));

    Team team = jsonTransformService.read(Team.class, payload);
    team.setRequestToken(authenticationService.getCurrentToken());

    this.queueMessagingTemplate.send(queue, MessageBuilder.withPayload(jsonTransformService.write(team)).build());

    return new ResponseEntity<>(HttpStatus.NO_CONTENT);
}
 

import org.springframework.messaging.support.MessageBuilder; //导入依赖的package包/类
@Test
public void testPreSendServerSpan() {
  MessageBuilder<String> messageBuilder = MessageBuilder.withPayload("Hi")
      .setHeader(TracingChannelInterceptor.SIMP_MESSAGE_TYPE, SimpMessageType.MESSAGE)
      .setHeader(TracingChannelInterceptor.SIMP_DESTINATION, TEST_DESTINATION);

  MockSpan parentSpan = mockTracer.buildSpan("parent").startManual();
  mockTracer.inject(parentSpan.context(), Format.Builtin.TEXT_MAP,
      new TextMapInjectAdapter(messageBuilder));

  TracingChannelInterceptor interceptor = new TracingChannelInterceptor(mockTracer,
      Tags.SPAN_KIND_SERVER);

  Message<?> processed = interceptor.preSend(messageBuilder.build(), null);

  // Verify span cached with message is child of propagated parentSpan span context
  assertTrue(processed.getHeaders().containsKey(TracingChannelInterceptor.OPENTRACING_SPAN));
  MockSpan childSpan = (MockSpan) processed.getHeaders()
      .get(TracingChannelInterceptor.OPENTRACING_SPAN);
  assertEquals(parentSpan.context().spanId(), childSpan.parentId());
  assertEquals(parentSpan.context().traceId(), childSpan.context().traceId());
  assertEquals(TEST_DESTINATION, childSpan.operationName());
  assertEquals(Tags.SPAN_KIND_SERVER, childSpan.tags().get(Tags.SPAN_KIND.getKey()));
  assertEquals(TracingChannelInterceptor.WEBSOCKET,
      childSpan.tags().get(Tags.COMPONENT.getKey()));
}
 

import org.springframework.messaging.support.MessageBuilder; //导入依赖的package包/类
/**
 * Overridden from the {@link MqttCallbackExtended#messageArrived(String, MqttMessage)} method.
 * <p>
 * If the {@code inboundMessageChannel} is not null, the received message is sent to this
 * {@link MessageChannel}.
 */
@Override
public void messageArrived(String topic, MqttMessage message) throws Exception
{
    try
    {
        if (inboundMessageChannel != null)
        {
            inboundMessageChannel.send(MessageBuilder.withPayload(message.getPayload().clone())
                .setHeader(MqttHeaderHelper.TOPIC, topic)
                .setHeader(MqttHeaderHelper.ID, message.getId())
                .setHeader(MqttHeaderHelper.QOS,
                    MqttQualityOfService.findByLevelIdentifier(message.getQos()))
                .setHeader(MqttHeaderHelper.RETAINED, message.isRetained())
                .setHeader(MqttHeaderHelper.DUPLICATE, message.isDuplicate()).build());
        }
    }
    catch (Exception | Error ex)
    {
        LOG.error(String.format(
            "Client ID %s could not send the message to the Inbound Channel. Topic: %s, Message: %s",
            getClientId(), topic, message.toString()), ex);
    }
}
 

import org.springframework.messaging.support.MessageBuilder; //导入依赖的package包/类
@Test
public void testMqttQualityOfServiceHeader()
{
    Assert.assertEquals(MqttQualityOfService.QOS_2,
        MqttHeaderHelper.getMqttQualityOfServiceHeaderValue(null,
            MqttQualityOfService.QOS_2.getLevelIdentifier()));
    MessageBuilder<String> builder = MessageBuilder.withPayload("See QoS header");
    Assert.assertEquals(MqttQualityOfService.QOS_2,
        MqttHeaderHelper.getMqttQualityOfServiceHeaderValue(builder.build(),
            MqttQualityOfService.QOS_2.getLevelIdentifier()));
    builder.setHeader(MqttHeaderHelper.QOS, "blah!");
    Assert.assertEquals(MqttQualityOfService.QOS_2,
        MqttHeaderHelper.getMqttQualityOfServiceHeaderValue(builder.build(),
            MqttQualityOfService.QOS_2.getLevelIdentifier()));
    builder.setHeader(MqttHeaderHelper.QOS, MqttQualityOfService.QOS_1.getLevelIdentifier());
    Assert.assertEquals(MqttQualityOfService.QOS_1,
        MqttHeaderHelper.getMqttQualityOfServiceHeaderValue(builder.build(),
            MqttQualityOfService.QOS_2.getLevelIdentifier()));
}
 

import org.springframework.messaging.support.MessageBuilder; //导入依赖的package包/类
@StreamListener(value = CloudConnectorChannels.INTEGRATION_EVENT_CONSUMER, condition = "headers['connectorType']=='SendRewardToWinners'")
public synchronized void tweet(IntegrationRequestEvent event)  {
    Map<String, Object> results = new HashMap<>();
    Collection winners = (Collection) event.getVariables().get("top");
    String campaign = String.valueOf(event.getVariables().get("campaign"));

    for(Object winner:winners){
        logger.info(append("service-name", appName),"#"+campaign+"#################################################################");
        logger.info(append("service-name", appName),"#  Reward time!!! You WON "+winner+"!!! ");
        logger.info(append("service-name", appName),"#################################################################################");
    }

    IntegrationResultEvent ire = new IntegrationResultEvent(event.getExecutionId(),
                                                            results);

    integrationResultsProducer.send(MessageBuilder.withPayload(ire).build());
}
 

import org.springframework.messaging.support.MessageBuilder; //导入依赖的package包/类
@Test
public void connectReceiveAndCloseWithStompFrame() throws Exception {
	StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.SEND);
	accessor.setDestination("/destination");
	MessageHeaders headers = accessor.getMessageHeaders();
	Message<byte[]> message = MessageBuilder.createMessage("body".getBytes(Charset.forName("UTF-8")), headers);
	byte[] bytes = new StompEncoder().encode(message);
	TextMessage textMessage = new TextMessage(bytes);
	SockJsFrame frame = SockJsFrame.messageFrame(new Jackson2SockJsMessageCodec(), textMessage.getPayload());

	String body = "o\n" + frame.getContent() + "\n" + "c[3000,\"Go away!\"]";
	ClientHttpResponse response = response(HttpStatus.OK, body);
	connect(response);

	verify(this.webSocketHandler).afterConnectionEstablished(any());
	verify(this.webSocketHandler).handleMessage(any(), eq(textMessage));
	verify(this.webSocketHandler).afterConnectionClosed(any(), eq(new CloseStatus(3000, "Go away!")));
	verifyNoMoreInteractions(this.webSocketHandler);
}
 

import org.springframework.messaging.support.MessageBuilder; //导入依赖的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.support.MessageBuilder; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private Message<byte[]> createMessage(StompHeaderAccessor accessor, Object payload) {
	accessor.updateSimpMessageHeadersFromStompHeaders();
	Message<byte[]> message;
	if (payload == null) {
		message = MessageBuilder.createMessage(EMPTY_PAYLOAD, accessor.getMessageHeaders());
	}
	else if (payload instanceof byte[]) {
		message = MessageBuilder.createMessage((byte[]) payload, accessor.getMessageHeaders());
	}
	else {
		message = (Message<byte[]>) getMessageConverter().toMessage(payload, accessor.getMessageHeaders());
		accessor.updateStompHeadersFromSimpMessageHeaders();
		if (message == null) {
			throw new MessageConversionException("Unable to convert payload with type='" +
					payload.getClass().getName() + "', contentType='" + accessor.getContentType() +
					"', converter=[" + getMessageConverter() + "]");
		}
	}
	return message;
}