Add MessageBuilder

spring-context/src/main/java/org/springframework/messaging/MessageChannel.java

@@ -23,6 +23,7 @@ package org.springframework.messaging;
  * @author Mark Fisher
  * @since 4.0
  */
+@SuppressWarnings("rawtypes")
 public interface MessageChannel<M extends Message> {
 
 	/**

spring-context/src/main/java/org/springframework/messaging/MessageFactory.java

@@ -22,9 +22,8 @@ import java.util.Map;
 /**
  * A factory for creating messages, allowing for control of the concrete type of the message.
  *
- *
- *
  * @author Andy Wilkinson
+ * @since 4.0
  */
 public interface MessageFactory<M extends Message<?>> {
 

spring-context/src/main/java/org/springframework/messaging/MessageHandler.java

@@ -24,6 +24,7 @@ package org.springframework.messaging;
  * @author Iwein Fuld
  * @since 4.0
  */
+@SuppressWarnings("rawtypes")
 public interface MessageHandler<M extends Message> {
 
 	/**

spring-context/src/main/java/org/springframework/messaging/SubscribableChannel.java

@@ -25,7 +25,9 @@ package org.springframework.messaging;
  * @author Mark Fisher
  * @since 4.0
  */
-public interface SubscribableChannel<M extends Message, H extends MessageHandler<M>> extends MessageChannel<M> {
+@SuppressWarnings("rawtypes")
+public interface SubscribableChannel<M extends Message, H extends MessageHandler<M>>
+		extends MessageChannel<M> {
 
 	/**
 	 * Register a {@link MessageHandler} as a subscriber to this channel.

spring-context/src/main/java/org/springframework/messaging/support/GenericMessage.java

@@ -14,12 +14,14 @@
  * limitations under the License.
  */
 
-package org.springframework.messaging;
+package org.springframework.messaging.support;
 
 import java.io.Serializable;
 import java.util.HashMap;
 import java.util.Map;
 
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageHeaders;
 import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
 

spring-context/src/main/java/org/springframework/messaging/support/GenericMessageFactory.java

@@ -14,20 +14,24 @@
  * limitations under the License.
  */
 
-package org.springframework.messaging;
+package org.springframework.messaging.support;
 
 import java.util.Map;
 
+import org.springframework.messaging.MessageFactory;
+
 
 /**
  * A {@link MessageFactory} that creates {@link GenericMessage GenericMessages}.
  *
  * @author Andy Wilkinson
+ * @since 4.0
  */
 public class GenericMessageFactory implements MessageFactory<GenericMessage<?>> {
 
+
 	@Override
-	public <P> GenericMessage<?> createMessage(P payload, Map<String, Object> headers) {
+	public <P> GenericMessage<P> createMessage(P payload, Map<String, Object> headers) {
 		return new GenericMessage<P>(payload, headers);
 	}
 

spring-context/src/main/java/org/springframework/messaging/support/MessageBuilder.java

@@ -0,0 +1,245 @@
+/*
+ * Copyright 2002-2010 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.support;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageFactory;
+import org.springframework.messaging.MessageHeaders;
+import org.springframework.util.Assert;
+import org.springframework.util.PatternMatchUtils;
+import org.springframework.util.StringUtils;
+
+/**
+ * @author Arjen Poutsma
+ * @author Mark Fisher
+ * @author Oleg Zhurakousky
+ * @author Dave Syer
+ * @since 4.0
+ */
+public final class MessageBuilder<T> {
+
+	private final T payload;
+
+	private final Map<String, Object> headers = new HashMap<String, Object>();
+
+	private final Message<T> originalMessage;
+
+	@SuppressWarnings("rawtypes")
+	private static volatile MessageFactory messageFactory = null;
+
+
+	/**
+	 * A constructor with payload and an optional message to copy headers from.
+	 * This is a private constructor to be invoked from the static factory methods only.
+	 *
+	 * @param payload the message payload, never {@code null}
+	 * @param originalMessage a message to copy from or re-use if no changes are made, can
+	 *        be {@code null}
+	 */
+	private MessageBuilder(T payload, Message<T> originalMessage) {
+		Assert.notNull(payload, "payload is required");
+		this.payload = payload;
+		this.originalMessage = originalMessage;
+		if (originalMessage != null) {
+			this.headers.putAll(originalMessage.getHeaders());
+		}
+	}
+
+	/**
+	 * Private constructor to be invoked from the static factory methods only.
+	 *
+	 * @param payload the message payload, never {@code null}
+	 * @param originalMessage a message to copy from or re-use if no changes are made, can
+	 *        be {@code null}
+	 */
+	private MessageBuilder(T payload, Map<String, Object> headers) {
+		Assert.notNull(payload, "payload is required");
+		Assert.notNull(headers, "headers is required");
+		this.payload = payload;
+		this.headers.putAll(headers);
+		this.originalMessage = null;
+	}
+
+	/**
+	 * Create a builder for a new {@link Message} instance pre-populated with all of the
+	 * headers copied from the provided message. The payload of the provided Message will
+	 * also be used as the payload for the new message.
+	 *
+	 * @param message the Message from which the payload and all headers will be copied
+	 */
+	public static <T> MessageBuilder<T> fromMessage(Message<T> message) {
+		Assert.notNull(message, "message must not be null");
+		MessageBuilder<T> builder = new MessageBuilder<T>(message.getPayload(), message);
+		return builder;
+	}
+
+	/**
+	 * Create a builder for a new {@link Message} instance with the provided payload and
+	 * headers.
+	 *
+	 * @param payload the payload for the new message
+	 * @param headers the headers to use
+	 */
+	public static <T> MessageBuilder<T> fromPayloadAndHeaders(T payload, Map<String, Object> headers) {
+		MessageBuilder<T> builder = new MessageBuilder<T>(payload, headers);
+		return builder;
+	}
+
+	/**
+	 * Create a builder for a new {@link Message} instance with the provided payload.
+	 *
+	 * @param payload the payload for the new message
+	 */
+	public static <T> MessageBuilder<T> withPayload(T payload) {
+		MessageBuilder<T> builder = new MessageBuilder<T>(payload, (Message<T>) null);
+		return builder;
+	}
+
+	/**
+	 * Set the value for the given header name. If the provided value is <code>null</code>
+	 * the header will be removed.
+	 */
+	public MessageBuilder<T> setHeader(String headerName, Object headerValue) {
+		Assert.isTrue(!this.isReadOnly(headerName), "The '" + headerName + "' header is read-only.");
+		if (StringUtils.hasLength(headerName)) {
+			putOrRemove(headerName, headerValue);
+		}
+		return this;
+	}
+
+	private boolean isReadOnly(String headerName) {
+		return MessageHeaders.ID.equals(headerName) || MessageHeaders.TIMESTAMP.equals(headerName);
+	}
+
+	private void putOrRemove(String headerName, Object headerValue) {
+		if (headerValue == null) {
+			this.headers.remove(headerName);
+		}
+		else {
+			this.headers.put(headerName, headerValue);
+		}
+	}
+
+	/**
+	 * Set the value for the given header name only if the header name is not already
+	 * associated with a value.
+	 */
+	public MessageBuilder<T> setHeaderIfAbsent(String headerName, Object headerValue) {
+		if (this.headers.get(headerName) == null) {
+			putOrRemove(headerName, headerValue);
+		}
+		return this;
+	}
+
+	/**
+	 * Removes all headers provided via array of 'headerPatterns'. As the name suggests
+	 * the array may contain simple matching patterns for header names. Supported pattern
+	 * styles are: "xxx*", "*xxx", "*xxx*" and "xxx*yyy".
+	 */
+	public MessageBuilder<T> removeHeaders(String... headerPatterns) {
+		List<String> toRemove = new ArrayList<String>();
+		for (String pattern : headerPatterns) {
+			if (StringUtils.hasLength(pattern)){
+				if (pattern.contains("*")){
+					for (String headerName : this.headers.keySet()) {
+						if (PatternMatchUtils.simpleMatch(pattern, headerName)){
+							toRemove.add(headerName);
+						}
+					}
+				}
+				else {
+					toRemove.add(pattern);
+				}
+			}
+		}
+		for (String headerName : toRemove) {
+			this.headers.remove(headerName);
+			putOrRemove(headerName, null);
+		}
+		return this;
+	}
+	/**
+	 * Remove the value for the given header name.
+	 */
+	public MessageBuilder<T> removeHeader(String headerName) {
+		if (StringUtils.hasLength(headerName) && !isReadOnly(headerName)) {
+			this.headers.remove(headerName);
+		}
+		return this;
+	}
+
+	/**
+	 * Copy the name-value pairs from the provided Map. This operation will overwrite any
+	 * existing values. Use { {@link #copyHeadersIfAbsent(Map)} to avoid overwriting
+	 * values. Note that the 'id' and 'timestamp' header values will never be overwritten.
+	 */
+	public MessageBuilder<T> copyHeaders(Map<String, ?> headersToCopy) {
+		Set<String> keys = headersToCopy.keySet();
+		for (String key : keys) {
+			if (!this.isReadOnly(key)) {
+				putOrRemove(key, headersToCopy.get(key));
+			}
+		}
+		return this;
+	}
+
+	/**
+	 * Copy the name-value pairs from the provided Map. This operation will <em>not</em>
+	 * overwrite any existing values.
+	 */
+	public MessageBuilder<T> copyHeadersIfAbsent(Map<String, ?> headersToCopy) {
+		Set<String> keys = headersToCopy.keySet();
+		for (String key : keys) {
+			if (!this.isReadOnly(key) && (this.headers.get(key) == null)) {
+				putOrRemove(key, headersToCopy.get(key));
+			}
+		}
+		return this;
+	}
+
+	@SuppressWarnings("unchecked")
+	public Message<T> build() {
+
+		if (this.originalMessage != null
+				&& this.headers.equals(this.originalMessage.getHeaders())
+				&& this.payload.equals(this.originalMessage.getPayload())) {
+
+			return this.originalMessage;
+		}
+
+//		if (this.payload instanceof Throwable) {
+//			return (Message<T>) new ErrorMessage((Throwable) this.payload, this.headers);
+//		}
+
+		this.headers.remove(MessageHeaders.ID);
+		this.headers.remove(MessageHeaders.TIMESTAMP);
+
+		if (messageFactory == null) {
+			return new GenericMessage<T>(this.payload, this.headers);
+		}
+		else {
+			return messageFactory.createMessage(payload, headers);
+		}
+	}
+
+}

spring-context/src/test/java/org/springframework/messaging/support/MessageBuilderTests.java

@@ -0,0 +1,169 @@
+/*
+ * Copyright 2002-2013 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.support;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import org.junit.Test;
+import org.springframework.messaging.Message;
+import org.springframework.messaging.MessageHeaders;
+
+import static org.junit.Assert.*;
+
+
+/**
+ * @author Mark Fisher
+ */
+public class MessageBuilderTests {
+
+	@Test
+	public void testSimpleMessageCreation() {
+		Message<String> message = MessageBuilder.withPayload("foo").build();
+		assertEquals("foo", message.getPayload());
+	}
+
+	@Test
+	public void testHeaderValues() {
+		Message<String> message = MessageBuilder.withPayload("test")
+				.setHeader("foo", "bar")
+				.setHeader("count", new Integer(123))
+				.build();
+		assertEquals("bar", message.getHeaders().get("foo", String.class));
+		assertEquals(new Integer(123), message.getHeaders().get("count", Integer.class));
+	}
+
+	@Test
+	public void testCopiedHeaderValues() {
+		Message<String> message1 = MessageBuilder.withPayload("test1")
+				.setHeader("foo", "1")
+				.setHeader("bar", "2")
+				.build();
+		Message<String> message2 = MessageBuilder.withPayload("test2")
+				.copyHeaders(message1.getHeaders())
+				.setHeader("foo", "42")
+				.setHeaderIfAbsent("bar", "99")
+				.build();
+		assertEquals("test1", message1.getPayload());
+		assertEquals("test2", message2.getPayload());
+		assertEquals("1", message1.getHeaders().get("foo"));
+		assertEquals("42", message2.getHeaders().get("foo"));
+		assertEquals("2", message1.getHeaders().get("bar"));
+		assertEquals("2", message2.getHeaders().get("bar"));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testIdHeaderValueReadOnly() {
+		UUID id = UUID.randomUUID();
+		MessageBuilder.withPayload("test").setHeader(MessageHeaders.ID, id);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void testTimestampValueReadOnly() {
+		Long timestamp = 12345L;
+		MessageBuilder.withPayload("test").setHeader(MessageHeaders.TIMESTAMP, timestamp).build();
+	}
+
+	@Test
+	public void copyHeadersIfAbsent() {
+		Message<String> message1 = MessageBuilder.withPayload("test1")
+				.setHeader("foo", "bar").build();
+		Message<String> message2 = MessageBuilder.withPayload("test2")
+				.setHeader("foo", 123)
+				.copyHeadersIfAbsent(message1.getHeaders())
+				.build();
+		assertEquals("test2", message2.getPayload());
+		assertEquals(123, message2.getHeaders().get("foo"));
+	}
+
+	@Test
+	public void createFromMessage() {
+		Message<String> message1 = MessageBuilder.withPayload("test")
+				.setHeader("foo", "bar").build();
+		Message<String> message2 = MessageBuilder.fromMessage(message1).build();
+		assertEquals("test", message2.getPayload());
+		assertEquals("bar", message2.getHeaders().get("foo"));
+	}
+
+	@Test
+	public void createIdRegenerated() {
+		Message<String> message1 = MessageBuilder.withPayload("test")
+				.setHeader("foo", "bar").build();
+		Message<String> message2 = MessageBuilder.fromMessage(message1).setHeader("another", 1).build();
+		assertEquals("bar", message2.getHeaders().get("foo"));
+		assertNotSame(message1.getHeaders().getId(), message2.getHeaders().getId());
+	}
+
+	@Test
+	public void testRemove() {
+		Message<Integer> message1 = MessageBuilder.withPayload(1)
+			.setHeader("foo", "bar").build();
+		Message<Integer> message2 = MessageBuilder.fromMessage(message1)
+			.removeHeader("foo")
+			.build();
+		assertFalse(message2.getHeaders().containsKey("foo"));
+	}
+
+	@Test
+	public void testSettingToNullRemoves() {
+		Message<Integer> message1 = MessageBuilder.withPayload(1)
+			.setHeader("foo", "bar").build();
+		Message<Integer> message2 = MessageBuilder.fromMessage(message1)
+			.setHeader("foo", null)
+			.build();
+		assertFalse(message2.getHeaders().containsKey("foo"));
+	}
+
+	@Test
+	public void testNotModifiedSameMessage() throws Exception {
+		Message<?> original = MessageBuilder.withPayload("foo").build();
+		Message<?> result = MessageBuilder.fromMessage(original).build();
+		assertEquals(original, result);
+	}
+
+	@Test
+	public void testContainsHeaderNotModifiedSameMessage() throws Exception {
+		Message<?> original = MessageBuilder.withPayload("foo").setHeader("bar", 42).build();
+		Message<?> result = MessageBuilder.fromMessage(original).build();
+		assertEquals(original, result);
+	}
+
+	@Test
+	public void testSameHeaderValueAddedNotModifiedSameMessage() throws Exception {
+		Message<?> original = MessageBuilder.withPayload("foo").setHeader("bar", 42).build();
+		Message<?> result = MessageBuilder.fromMessage(original).setHeader("bar", 42).build();
+		assertEquals(original, result);
+	}
+
+	@Test
+	public void testCopySameHeaderValuesNotModifiedSameMessage() throws Exception {
+		Date current = new Date();
+		Map<String, Object> originalHeaders = new HashMap<String, Object>();
+		originalHeaders.put("b", "xyz");
+		originalHeaders.put("c", current);
+		Message<?> original = MessageBuilder.withPayload("foo").setHeader("a", 123).copyHeaders(originalHeaders).build();
+		Map<String, Object> newHeaders = new HashMap<String, Object>();
+		newHeaders.put("a", 123);
+		newHeaders.put("b", "xyz");
+		newHeaders.put("c", current);
+		Message<?> result = MessageBuilder.fromMessage(original).copyHeaders(newHeaders).build();
+		assertEquals(original, result);
+	}
+
+}