Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2002-2014 the original author or authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.springframework.messaging.core;
 
 import java.util.Map;
 
 
Abstract base class for implementations of MessageSendingOperations.

Author(s):
Mark Fisher
Rossen Stoyanchev
Since:
4.0
 
 public abstract class AbstractMessageSendingTemplate<D> implements MessageSendingOperations<D> {
 
 	protected final Log logger = LogFactory.getLog(getClass());
 
 	private volatile D defaultDestination;
 
 	private volatile MessageConverter converter = new SimpleMessageConverter();


Configure the default destination to use in send methods that don't have a destination argument. If a default destination is not configured, send methods without a destination argument will raise an exception if invoked.
 
 	public void setDefaultDestination(D defaultDestination) {
 		this. = defaultDestination;
 	}

Return the configured default destination.
 
 	public D getDefaultDestination() {
 		return this.;
 	}

Set the org.springframework.messaging.converter.MessageConverter to use in convertAndSend methods.

By default, org.springframework.messaging.converter.SimpleMessageConverter is used.

Parameters:
messageConverter the message converter to use
 
 	public void setMessageConverter(MessageConverter messageConverter) {
 		Assert.notNull(messageConverter"'messageConverter' must not be null");
 		this. = messageConverter;
 	}

 
 		return this.;
 	}
 
 
 	public void send(Message<?> message) {
 	}
 
 	protected final D getRequiredDefaultDestination() {
 		Assert.state(this. != null"No 'defaultDestination' configured");
 		return this.;
 	}
 
 	public void send(D destinationMessage<?> message) {
 		doSend(destinationmessage);
 	}
 
 	protected abstract void doSend(D destinationMessage<?> message);
 
 
	public void convertAndSend(Object payloadthrows MessagingException {
	}
	public void convertAndSend(D destinationObject payloadthrows MessagingException {
		convertAndSend(destinationpayload, (Map<StringObject>) null);
	}
	public void convertAndSend(D destinationObject payloadMap<StringObjectheadersthrows MessagingException {
		convertAndSend(destinationpayloadheadersnull);
	}
	public void convertAndSend(Object payloadMessagePostProcessor postProcessorthrows MessagingException {
		convertAndSend(getRequiredDefaultDestination(), payloadpostProcessor);
	}
	public void convertAndSend(D destinationObject payloadMessagePostProcessor postProcessor)
		convertAndSend(destinationpayloadnullpostProcessor);
	}
	public void convertAndSend(D destinationObject payloadMap<StringObjectheaders,
			MessagePostProcessor postProcessorthrows MessagingException {
		Map<StringObjectheadersToUse = processHeadersToSend(headers);
		MessageHeaders messageHeaders = (headersToUse != null ? new MessageHeaders(headersToUse) : null);
		Message<?> message = getMessageConverter().toMessage(payloadmessageHeaders);
		if (message == null) {
			String payloadType = (payload != null ? payload.getClass().getName() : null);
			Object contentType = (messageHeaders != null ? messageHeaders.get(.) : null);
			throw new MessageConversionException("Unable to convert payload with type='" + payloadType +
					"', contentType='" + contentType + "', converter=[" + getMessageConverter() + "]");
		}
		if (postProcessor != null) {
			message = postProcessor.postProcessMessage(message);
		}
		send(destinationmessage);
	}

Provides access to the map of input headers before a send operation. Sub-classes can modify the headers and then return the same or a different map.

This default implementation in this class returns the input map.

Parameters:
headers the headers to send or null
Returns:
the actual headers to send or null
	protected Map<StringObjectprocessHeadersToSend(Map<StringObjectheaders) {
		return headers;
	}
New to GrepCode? Check out our FAQ X