import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
public static void main(String[] args) {
	DefaultSetting.setDefaultNetwork();
	if(args.length==0){
		OutputMessage.error("please enter parameter");
		return;
	}
	Map<String, String> params = parseParamsToMap(args);
	if(params==null){
		return;
	}
	// set host, port and websocket port
	DefaultSetting.setHostAndPort(params.get("host"), params.get("port"), params.get("wsPort"));
	final String address = params.get("address");
	final String WS_URI = DefaultSetting.getWsUri();
	// create WebSocket client
	List<Transport> transports = new ArrayList<Transport>(1);
	transports.add(new WebSocketTransport(new StandardWebSocketClient()));
	WebSocketClient transport = new SockJsClient(transports);
	WebSocketStompClient stompClient = new WebSocketStompClient(transport);
	stompClient.setMessageConverter(new StringMessageConverter());
	StompSessionHandler handler = new WsMonitorMultisigHandler(address);
	stompClient.connect(WS_URI, handler);
	//block and monitor exit action
	ScannerUtil.monitorExit();
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
public static void main(String[] args) {
	DefaultSetting.setDefaultNetwork();
	if(args.length==0){
		OutputMessage.error("please enter parameter");
		return;
	}
	Map<String, String> params = parseParamsToMap(args);
	if(params==null){
		return;
	}
	// set host, port and websocket port
	DefaultSetting.setHostAndPort(params.get("host"), params.get("port"), params.get("wsPort"));
	final String address = params.get("address");
	final String WS_URI = DefaultSetting.getWsUri();
	// create WebSocket client
	List<Transport> transports = new ArrayList<Transport>(1);
	transports.add(new WebSocketTransport(new StandardWebSocketClient()));
	WebSocketClient transport = new SockJsClient(transports);
	WebSocketStompClient stompClient = new WebSocketStompClient(transport);
	stompClient.setMessageConverter(new StringMessageConverter());
	StompSessionHandler handler = new WsMonitorImcomingHandler(address);
	stompClient.connect(WS_URI, handler);
	//block and monitor exit action
	ScannerUtil.monitorExit();
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的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.StringMessageConverter; //导入依赖的package包/类
@Before
public void setup() throws Exception {
	MockitoAnnotations.initMocks(this);

	SimpMessagingTemplate messagingTemplate = new SimpMessagingTemplate(this.messageChannel);
	messagingTemplate.setMessageConverter(new StringMessageConverter());
	this.handler = new SubscriptionMethodReturnValueHandler(messagingTemplate);

	SimpMessagingTemplate jsonMessagingTemplate = new SimpMessagingTemplate(this.messageChannel);
	jsonMessagingTemplate.setMessageConverter(new MappingJackson2MessageConverter());
	this.jsonHandler = new SubscriptionMethodReturnValueHandler(jsonMessagingTemplate);

	Method method = this.getClass().getDeclaredMethod("getData");
	this.subscribeEventReturnType = new MethodParameter(method, -1);

	method = this.getClass().getDeclaredMethod("getDataAndSendTo");
	this.subscribeEventSendToReturnType = new MethodParameter(method, -1);

	method = this.getClass().getDeclaredMethod("handle");
	this.messageMappingReturnType = new MethodParameter(method, -1);

	method = this.getClass().getDeclaredMethod("getJsonView");
	this.subscribeEventJsonViewReturnType = new MethodParameter(method, -1);
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的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.StringMessageConverter; //导入依赖的package包/类
@Before
public void setUp() throws Exception {

	logger.debug("Setting up before '" + this.testName.getMethodName() + "'");

	this.wac = new AnnotationConfigWebApplicationContext();
	this.wac.register(TestConfig.class);
	this.wac.refresh();

	this.server = new TomcatWebSocketTestServer();
	this.server.setup();
	this.server.deployConfig(this.wac);
	this.server.start();

	WebSocketClient webSocketClient = new StandardWebSocketClient();
	this.stompClient = new WebSocketStompClient(webSocketClient);
	this.stompClient.setMessageConverter(new StringMessageConverter());
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的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.StringMessageConverter; //导入依赖的package包/类
@Test
public void fromMessage_withMessageAndSubject_shouldReturnMessage() throws Exception {
    // Arrange
    ObjectNode jsonObject = JsonNodeFactory.instance.objectNode();
    jsonObject.put("Type", "Notification");
    jsonObject.put("Subject", "Hello");
    jsonObject.put("Message", "World");
    String payload = jsonObject.toString();

    // Act
    Object notificationRequest = new NotificationRequestConverter(new StringMessageConverter()).fromMessage(MessageBuilder.withPayload(payload).build(), String.class);

    // Assert
    assertTrue(NotificationRequestConverter.NotificationRequest.class.isInstance(notificationRequest));
    assertEquals("Hello", ((NotificationRequestConverter.NotificationRequest) notificationRequest).getSubject());
    assertEquals("World", ((NotificationRequestConverter.NotificationRequest) notificationRequest).getMessage());
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
@Test
public void resolveArgument_withValidMessagePayload_shouldReturnNotificationMessage() throws Exception {
    // Arrange
    NotificationMessageArgumentResolver notificationMessageArgumentResolver = new NotificationMessageArgumentResolver(new StringMessageConverter());
    Method methodWithNotificationMessageArgument = this.getClass().getDeclaredMethod("methodWithNotificationMessageArgument", String.class);
    MethodParameter methodParameter = new MethodParameter(methodWithNotificationMessageArgument, 0);

    ObjectNode jsonObject = JsonNodeFactory.instance.objectNode();
    jsonObject.put("Type", "Notification");
    jsonObject.put("Message", "Hello World!");
    String payload = jsonObject.toString();
    Message<String> message = MessageBuilder.withPayload(payload).build();

    // Act
    Object result = notificationMessageArgumentResolver.resolveArgument(methodParameter, message);

    // Assert
    assertTrue(String.class.isInstance(result));
    assertEquals("Hello World!", result);
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
public PubSubInboundChannelAdapter(PubSubOperations pubSubTemplate, String subscriptionName) {
	this.pubSubTemplate = pubSubTemplate;
	this.subscriptionName = subscriptionName;

	StringMessageConverter stringMessageConverter = new StringMessageConverter();
	stringMessageConverter.setSerializedPayloadClass(String.class);
	this.messageConverter = stringMessageConverter;
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
@Bean
public CompositeMessageConverter brokerMessageConverter() {
	List<MessageConverter> converters = new ArrayList<MessageConverter>();
	boolean registerDefaults = configureMessageConverters(converters);
	if (registerDefaults) {
		converters.add(new StringMessageConverter());
		converters.add(new ByteArrayMessageConverter());
		if (jackson2Present) {
			converters.add(createJacksonConverter());
		}
	}
	return new CompositeMessageConverter(converters);
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
@Before
public void setup() throws Exception {
	MockitoAnnotations.initMocks(this);

	SimpMessagingTemplate messagingTemplate = new SimpMessagingTemplate(this.messageChannel);
	messagingTemplate.setMessageConverter(new StringMessageConverter());
	this.handler = new SendToMethodReturnValueHandler(messagingTemplate, true);
	this.handlerAnnotationNotRequired = new SendToMethodReturnValueHandler(messagingTemplate, false);

	SimpMessagingTemplate jsonMessagingTemplate = new SimpMessagingTemplate(this.messageChannel);
	jsonMessagingTemplate.setMessageConverter(new MappingJackson2MessageConverter());
	this.jsonHandler = new SendToMethodReturnValueHandler(jsonMessagingTemplate, true);

	Method method = this.getClass().getDeclaredMethod("handleNoAnnotations");
	this.noAnnotationsReturnType = new SynthesizingMethodParameter(method, -1);

	method = this.getClass().getDeclaredMethod("handleAndSendToDefaultDestination");
	this.sendToDefaultDestReturnType = new SynthesizingMethodParameter(method, -1);

	method = this.getClass().getDeclaredMethod("handleAndSendTo");
	this.sendToReturnType = new SynthesizingMethodParameter(method, -1);

	method = this.getClass().getDeclaredMethod("handleAndSendToWithPlaceholders");
	this.sendToWithPlaceholdersReturnType = new SynthesizingMethodParameter(method, -1);

	method = this.getClass().getDeclaredMethod("handleAndSendToUser");
	this.sendToUserReturnType = new SynthesizingMethodParameter(method, -1);

	method = this.getClass().getDeclaredMethod("handleAndSendToUserSingleSession");
	this.sendToUserSingleSessionReturnType = new SynthesizingMethodParameter(method, -1);

	method = this.getClass().getDeclaredMethod("handleAndSendToUserDefaultDestination");
	this.sendToUserDefaultDestReturnType = new SynthesizingMethodParameter(method, -1);

	method = this.getClass().getDeclaredMethod("handleAndSendToUserDefaultDestinationSingleSession");
	this.sendToUserSingleSessionDefaultDestReturnType = new SynthesizingMethodParameter(method, -1);

	method = this.getClass().getDeclaredMethod("handleAndSendToJsonView");
	this.jsonViewReturnType = new SynthesizingMethodParameter(method, -1);
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
@Before
public void setUp() throws Exception {

	MockitoAnnotations.initMocks(this);

	this.sessionHandler = mock(StompSessionHandler.class);
	this.connectHeaders = new StompHeaders();
	this.session = new DefaultStompSession(this.sessionHandler, this.connectHeaders);
	this.session.setMessageConverter(new StringMessageConverter());

	SettableListenableFuture<Void> future = new SettableListenableFuture<>();
	future.set(null);
	when(this.connection.send(this.messageCaptor.capture())).thenReturn(future);
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
@Test
public void configureMessageConvertersDefault() {
	AbstractMessageBrokerConfiguration config = new BaseTestMessageBrokerConfig();
	CompositeMessageConverter compositeConverter = config.brokerMessageConverter();

	List<MessageConverter> converters = compositeConverter.getConverters();
	assertThat(converters.size(), Matchers.is(3));
	assertThat(converters.get(0), Matchers.instanceOf(StringMessageConverter.class));
	assertThat(converters.get(1), Matchers.instanceOf(ByteArrayMessageConverter.class));
	assertThat(converters.get(2), Matchers.instanceOf(MappingJackson2MessageConverter.class));

	ContentTypeResolver resolver = ((MappingJackson2MessageConverter) converters.get(2)).getContentTypeResolver();
	assertEquals(MimeTypeUtils.APPLICATION_JSON, ((DefaultContentTypeResolver) resolver).getDefaultMimeType());
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
@Before
public void setup() throws Exception {
	this.resolver = new PayloadArgumentResolver(new StringMessageConverter(), testValidator());
	this.payloadMethod = PayloadArgumentResolverTests.class.getDeclaredMethod("handleMessage",
			String.class, String.class, Locale.class, String.class, String.class, String.class, String.class);

	this.paramAnnotated = new SynthesizingMethodParameter(this.payloadMethod, 0);
	this.paramAnnotatedNotRequired = new SynthesizingMethodParameter(this.payloadMethod, 1);
	this.paramAnnotatedRequired = new SynthesizingMethodParameter(payloadMethod, 2);
	this.paramWithSpelExpression = new SynthesizingMethodParameter(payloadMethod, 3);
	this.paramValidated = new SynthesizingMethodParameter(this.payloadMethod, 4);
	this.paramValidated.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
	this.paramValidatedNotAnnotated = new SynthesizingMethodParameter(this.payloadMethod, 5);
	this.paramNotAnnotated = new SynthesizingMethodParameter(this.payloadMethod, 6);
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
@Test
public void convertAndSendPayloadAndMutableHeadersToDestination() {
	MessageHeaderAccessor accessor = new MessageHeaderAccessor();
	accessor.setHeader("foo", "bar");
	accessor.setLeaveMutable(true);
	MessageHeaders messageHeaders = accessor.getMessageHeaders();

	this.template.setMessageConverter(new StringMessageConverter());
	this.template.convertAndSend("somewhere", "payload", messageHeaders);

	MessageHeaders actual = this.template.message.getHeaders();
	assertSame(messageHeaders, actual);
	assertEquals(new MimeType("text", "plain", Charset.forName("UTF-8")), actual.get(MessageHeaders.CONTENT_TYPE));
	assertEquals("bar", actual.get("foo"));
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
private RuntimeBeanReference registerMessageConverter(Element element, ParserContext context, Object source) {
	Element convertersElement = DomUtils.getChildElementByTagName(element, "message-converters");
	ManagedList<? super Object> converters = new ManagedList<Object>();
	if (convertersElement != null) {
		converters.setSource(source);
		for (Element beanElement : DomUtils.getChildElementsByTagName(convertersElement, "bean", "ref")) {
			Object object = context.getDelegate().parsePropertySubElement(beanElement, null);
			converters.add(object);
		}
	}
	if (convertersElement == null || Boolean.valueOf(convertersElement.getAttribute("register-defaults"))) {
		converters.setSource(source);
		converters.add(new RootBeanDefinition(StringMessageConverter.class));
		converters.add(new RootBeanDefinition(ByteArrayMessageConverter.class));
		if (jackson2Present) {
			RootBeanDefinition jacksonConverterDef = new RootBeanDefinition(MappingJackson2MessageConverter.class);
			RootBeanDefinition resolverDef = new RootBeanDefinition(DefaultContentTypeResolver.class);
			resolverDef.getPropertyValues().add("defaultMimeType", MimeTypeUtils.APPLICATION_JSON);
			jacksonConverterDef.getPropertyValues().add("contentTypeResolver", resolverDef);
			// Use Jackson factory in order to have JSR-310 and Joda-Time modules registered automatically
			GenericBeanDefinition jacksonFactoryDef = new GenericBeanDefinition();
			jacksonFactoryDef.setBeanClass(Jackson2ObjectMapperFactoryBean.class);
			jacksonFactoryDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
			jacksonFactoryDef.setSource(source);
			jacksonConverterDef.getPropertyValues().add("objectMapper", jacksonFactoryDef);
			converters.add(jacksonConverterDef);
		}
	}
	ConstructorArgumentValues cavs = new ConstructorArgumentValues();
	cavs.addIndexedArgumentValue(0, converters);
	RootBeanDefinition messageConverterDef = new RootBeanDefinition(CompositeMessageConverter.class, cavs, null);
	return new RuntimeBeanReference(registerBeanDef(messageConverterDef, context, source));
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
@Test
public void messageConverters() {
	loadBeanDefinitions("websocket-config-broker-converters.xml");

	CompositeMessageConverter compositeConverter = this.appContext.getBean(CompositeMessageConverter.class);
	assertNotNull(compositeConverter);

	assertEquals(4, compositeConverter.getConverters().size());
	assertEquals(StringMessageConverter.class, compositeConverter.getConverters().iterator().next().getClass());
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
@Test
public void messageConvertersDefaultsOff() {
	loadBeanDefinitions("websocket-config-broker-converters-defaults-off.xml");

	CompositeMessageConverter compositeConverter = this.appContext.getBean(CompositeMessageConverter.class);
	assertNotNull(compositeConverter);

	assertEquals(1, compositeConverter.getConverters().size());
	assertEquals(StringMessageConverter.class, compositeConverter.getConverters().iterator().next().getClass());
}
 

import org.springframework.messaging.converter.StringMessageConverter; //导入依赖的package包/类
@Override
public boolean configureMessageConverters(List<MessageConverter> messageConverters) {
    messageConverters.add(new StringMessageConverter());
    messageConverters.add(new ByteArrayMessageConverter());

    GsonMessageConverter gsonMessageConverter = new GsonMessageConverter();
    gsonMessageConverter.setGson(Converters.registerDateTime(new GsonBuilder()).create());
    messageConverters.add(gsonMessageConverter);

    return false;
}