Java MessageConverter类代码示例

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(WebSocketStompClient.class)
public WebSocketStompClient stompClient(MessageConverter messageConverter,
                                        ThreadPoolTaskScheduler taskScheduler) {
    int bufferSizeLimit = 1024 * 1024 * 8;

    StandardWebSocketClient webSocketClient = new StandardWebSocketClient();
    List<Transport> transports = new ArrayList<>();
    transports.add(new WebSocketTransport(webSocketClient));
    SockJsClient sockJsClient = new SockJsClient(transports);
    WebSocketStompClient client = new WebSocketStompClient(sockJsClient);
    client.setInboundMessageSizeLimit(bufferSizeLimit);
    client.setMessageConverter(messageConverter);
    client.setTaskScheduler(taskScheduler);
    client.setDefaultHeartbeat(new long[]{0, 0});
    return client;
}
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
/**
 * Create an instance of SimpAnnotationMethodMessageHandler with the given
 * message channels and broker messaging template.
 * @param clientInboundChannel the channel for receiving messages from clients (e.g. WebSocket clients)
 * @param clientOutboundChannel the channel for messages to clients (e.g. WebSocket clients)
 * @param brokerTemplate a messaging template to send application messages to the broker
 */
public SimpAnnotationMethodMessageHandler(SubscribableChannel clientInboundChannel,
		MessageChannel clientOutboundChannel, SimpMessageSendingOperations brokerTemplate) {

	Assert.notNull(clientInboundChannel, "clientInboundChannel must not be null");
	Assert.notNull(clientOutboundChannel, "clientOutboundChannel must not be null");
	Assert.notNull(brokerTemplate, "brokerTemplate must not be null");

	this.clientInboundChannel = clientInboundChannel;
	this.clientMessagingTemplate = new SimpMessagingTemplate(clientOutboundChannel);
	this.brokerTemplate = brokerTemplate;

	Collection<MessageConverter> converters = new ArrayList<MessageConverter>();
	converters.add(new StringMessageConverter());
	converters.add(new ByteArrayMessageConverter());
	this.messageConverter = new CompositeMessageConverter(converters);
}
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
void addRemoteRegistryDto(Message<?> message, MessageConverter converter, long expirationPeriod) {
	UserRegistryDto registryDto = (UserRegistryDto) converter.fromMessage(message, UserRegistryDto.class);
	if (registryDto != null && !registryDto.getId().equals(this.id)) {
		long expirationTime = System.currentTimeMillis() + expirationPeriod;
		registryDto.setExpirationTime(expirationTime);
		registryDto.restoreParentReferences();
		this.remoteRegistries.put(registryDto.getId(), registryDto);
	}
}
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
@Test
public void configureMessageConvertersCustom() {
	final MessageConverter testConverter = mock(MessageConverter.class);
	AbstractMessageBrokerConfiguration config = new BaseTestMessageBrokerConfig() {
		@Override
		protected boolean configureMessageConverters(List<MessageConverter> messageConverters) {
			messageConverters.add(testConverter);
			return false;
		}
	};

	CompositeMessageConverter compositeConverter = config.brokerMessageConverter();
	assertThat(compositeConverter.getConverters().size(), Matchers.is(1));
	Iterator<MessageConverter> iterator = compositeConverter.getConverters().iterator();
	assertThat(iterator.next(), Matchers.is(testConverter));
}
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
@Test
public void configureMessageConvertersCustomAndDefault() {
	final MessageConverter testConverter = mock(MessageConverter.class);

	AbstractMessageBrokerConfiguration config = new BaseTestMessageBrokerConfig() {
		@Override
		protected boolean configureMessageConverters(List<MessageConverter> messageConverters) {
			messageConverters.add(testConverter);
			return true;
		}
	};
	CompositeMessageConverter compositeConverter = config.brokerMessageConverter();

	assertThat(compositeConverter.getConverters().size(), Matchers.is(4));
	Iterator<MessageConverter> iterator = compositeConverter.getConverters().iterator();
	assertThat(iterator.next(), Matchers.is(testConverter));
	assertThat(iterator.next(), Matchers.instanceOf(StringMessageConverter.class));
	assertThat(iterator.next(), Matchers.instanceOf(ByteArrayMessageConverter.class));
	assertThat(iterator.next(), Matchers.instanceOf(MappingJackson2MessageConverter.class));
}
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
private void sendHistoryToNewSubscriber(AbstractSubProtocolEvent ev) {
    Message<byte[]> msg = ev.getMessage();
    StompHeaderAccessor ha = StompHeaderAccessor.wrap(msg);
    String pattern = ha.getDestination();
    if(!pattern.startsWith(PREFIX)) {
        // we must send only to appropriate paths
        return;
    }
    MessageConverter messageConverter = this.simpMessagingTemplate.getMessageConverter();

    for(BusData data: buses.values()) {
        String dest = getDestination(data.getId());
        if(!this.pathMatcher.match(pattern, dest)) {
            continue;
        }
        for(Object obj: data.getEvents()) {
            StompHeaderAccessor mha = Stomp.createHeaders(ha.getSessionId(), ha.getSubscriptionId());
            mha.setDestination(dest);
            Message<?> message = messageConverter.toMessage(obj, mha.getMessageHeaders());
            clientChannel.send(message);
        }
    }
}
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
@Bean
public QueueMessageHandler sqsMessageHandler() {
  Collection<MessageConverter> converters = new ArrayList<>();
  MappingJackson2MessageConverter jacksonConverter = new MappingJackson2MessageConverter();
  jacksonConverter.setSerializedPayloadClass(String.class);
  jacksonConverter.setStrictContentTypeMatch(false);
  converters.add(jacksonConverter);

  List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>();
  CompositeMessageConverter compositeMessageConverter = new CompositeMessageConverter(converters);
  resolvers.add(new NotificationMessageArgumentResolver(compositeMessageConverter));
  resolvers.add(new PayloadArgumentResolver(compositeMessageConverter));

  QueueMessageHandler handler = sqsMessageHandlerFactory().createQueueMessageHandler();
  handler.setArgumentResolvers(resolvers);
  return handler;
}
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
@Test
public void testConfigureOutputChannelWithBadContentType() {
	BindingServiceProperties props = new BindingServiceProperties();
	BindingProperties bindingProps = new BindingProperties();
	bindingProps.setContentType("application/json");
	props.setBindings(Collections.singletonMap("foo", bindingProps));
	CompositeMessageConverterFactory converterFactory = new CompositeMessageConverterFactory(
			Collections.<MessageConverter>emptyList(), null);
	MessageConverterConfigurer configurer = new MessageConverterConfigurer(props, converterFactory);
	QueueChannel out = new QueueChannel();
	configurer.configureOutputChannel(out, "foo");
	out.send(new GenericMessage<Foo>(new Foo(),
			Collections.<String, Object> singletonMap(MessageHeaders.CONTENT_TYPE, "bad/ct")));
	Message<?> received = out.receive(0);
	assertThat(received).isNotNull();
	assertThat(received.getPayload()).isInstanceOf(Foo.class);
}
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
@Test
public void testConfigureInputChannelWithLegacyContentType() {
	BindingServiceProperties props = new BindingServiceProperties();
	BindingProperties bindingProps = new BindingProperties();
	bindingProps.setContentType("foo/bar");
	props.setBindings(Collections.singletonMap("foo", bindingProps));
	CompositeMessageConverterFactory converterFactory = new CompositeMessageConverterFactory(
			Collections.<MessageConverter>emptyList(), null);
	MessageConverterConfigurer configurer = new MessageConverterConfigurer(props, converterFactory);
	QueueChannel in = new QueueChannel();
	configurer.configureInputChannel(in, "foo");
	Foo foo = new Foo();
	in.send(
			MessageBuilder.withPayload(foo)
				.setHeader(BinderHeaders.BINDER_ORIGINAL_CONTENT_TYPE, "application/json")
				.setHeader(BinderHeaders.SCST_VERSION, "1.x")
				.build());
	Message<?> received = in.receive(0);
	assertThat(received).isNotNull();
	assertThat(received.getPayload()).isEqualTo(foo);
	assertThat(received.getHeaders().get(MessageHeaders.CONTENT_TYPE).toString()).isEqualTo("application/json");
}
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
@Bean
@StreamMessageConverter
public MessageConverter userMessageConverter() throws IOException {
	AvroSchemaMessageConverter avroSchemaMessageConverter = new AvroSchemaMessageConverter(
			MimeType.valueOf("avro/bytes"));
	if (schemaLocation != null) {
		avroSchemaMessageConverter.setSchemaLocation(schemaLocation);
	}
	return avroSchemaMessageConverter;
}
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
private CompositeMessageConverter createPayloadArgumentCompositeConverter() {
    List<MessageConverter> payloadArgumentConverters = new ArrayList<>();

    if (JACKSON_2_PRESENT) {
        MappingJackson2MessageConverter jacksonMessageConverter = new MappingJackson2MessageConverter();
        jacksonMessageConverter.setObjectMapper(Jackson2ObjectMapperBuilder.json().build());
        jacksonMessageConverter.setSerializedPayloadClass(String.class);
        jacksonMessageConverter.setStrictContentTypeMatch(true);
        payloadArgumentConverters.add(jacksonMessageConverter);
    }

    ObjectMessageConverter objectMessageConverter = new ObjectMessageConverter();
    objectMessageConverter.setStrictContentTypeMatch(true);
    payloadArgumentConverters.add(objectMessageConverter);

    payloadArgumentConverters.add(new SimpleMessageConverter());

    return new CompositeMessageConverter(payloadArgumentConverters);
}
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
protected void initMessageConverter(MessageConverter messageConverter) {

        StringMessageConverter stringMessageConverter = new StringMessageConverter();
        stringMessageConverter.setSerializedPayloadClass(String.class);

        List<MessageConverter> messageConverters = new ArrayList<>();
        messageConverters.add(stringMessageConverter);

        if (messageConverter != null) {
            messageConverters.add(messageConverter);
        } else if (JACKSON_2_PRESENT) {
            MappingJackson2MessageConverter mappingJackson2MessageConverter = new MappingJackson2MessageConverter();
            mappingJackson2MessageConverter.setObjectMapper(Jackson2ObjectMapperBuilder.json().build());
            mappingJackson2MessageConverter.setSerializedPayloadClass(String.class);
            messageConverters.add(mappingJackson2MessageConverter);
        }

        setMessageConverter(new CompositeMessageConverter(messageConverters));
    }
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
@Test
public void parseInternal_withCustomConverter_mustBeSetOnTemplate() throws Exception {
    //Arrange
    DefaultListableBeanFactory registry = new DefaultListableBeanFactory();
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(registry);

    //Act
    reader.loadBeanDefinitions(new ClassPathResource(getClass().getSimpleName() + "-custom-converter.xml", getClass()));

    //Assert
    QueueMessagingTemplate queueMessagingTemplateBeanDefinition = registry.getBean(QueueMessagingTemplate.class);
    MessageConverter messageConverter = queueMessagingTemplateBeanDefinition.getMessageConverter();
    assertTrue(CompositeMessageConverter.class.isInstance(messageConverter));
    CompositeMessageConverter compositeMessageConverter = (CompositeMessageConverter) messageConverter;
    assertEquals(2, compositeMessageConverter.getConverters().size());
    assertTrue(ObjectMessageConverter.class.isInstance(compositeMessageConverter.getConverters().get(1)));
}
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
@Bean
public MessageConverter bookingOrderMessageConverter() throws IOException {
    LOG.info("avro message converter bean initialized.");
    AvroSchemaMessageConverter avroSchemaMessageConverter = new AvroSchemaMessageConverter(MimeType.valueOf("application/bookingOrder.v1+avro"));
    avroSchemaMessageConverter.setSchemaLocation(new ClassPathResource("avro/bookingOrder.avsc"));
    return avroSchemaMessageConverter;
}
 

import org.springframework.messaging.converter.MessageConverter; //导入依赖的package包/类
/**
 * Configure a {@link MessageConverter} to use to convert the payload of a message from
 * its serialized form with a specific MIME type to an Object matching the target method
 * parameter. The converter is also used when sending a message to the message broker.
 * @see CompositeMessageConverter
 */
public void setMessageConverter(MessageConverter converter) {
	this.messageConverter = converter;
	if (converter != null) {
		((AbstractMessageSendingTemplate<?>) this.clientMessagingTemplate).setMessageConverter(converter);
	}
}