org.springframework.messaging.support.MessageBuilder Maven / Gradle / Ivy
/*
* Copyright 2002-2019 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
*
* https://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.Map;
import org.springframework.lang.Nullable;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHeaders;
import org.springframework.util.Assert;
/**
* A builder for creating a {@link GenericMessage}
* (or {@link ErrorMessage} if the payload is of type {@link Throwable}).
*
* @author Arjen Poutsma
* @author Mark Fisher
* @author Rossen Stoyanchev
* @since 4.0
* @param the message payload type
* @see GenericMessage
* @see ErrorMessage
*/
public final class MessageBuilder {
private final T payload;
@Nullable
private final Message providedMessage;
private MessageHeaderAccessor headerAccessor;
private MessageBuilder(Message providedMessage) {
Assert.notNull(providedMessage, "Message must not be null");
this.payload = providedMessage.getPayload();
this.providedMessage = providedMessage;
this.headerAccessor = new MessageHeaderAccessor(providedMessage);
}
private MessageBuilder(T payload, MessageHeaderAccessor accessor) {
Assert.notNull(payload, "Payload must not be null");
Assert.notNull(accessor, "MessageHeaderAccessor must not be null");
this.payload = payload;
this.providedMessage = null;
this.headerAccessor = accessor;
}
/**
* Set the message headers to use by providing a {@code MessageHeaderAccessor}.
* @param accessor the headers to use
*/
public MessageBuilder setHeaders(MessageHeaderAccessor accessor) {
Assert.notNull(accessor, "MessageHeaderAccessor must not be null");
this.headerAccessor = accessor;
return this;
}
/**
* Set the value for the given header name. If the provided value is {@code null},
* the header will be removed.
*/
public MessageBuilder setHeader(String headerName, @Nullable Object headerValue) {
this.headerAccessor.setHeader(headerName, headerValue);
return this;
}
/**
* Set the value for the given header name only if the header name is not already
* associated with a value.
*/
public MessageBuilder setHeaderIfAbsent(String headerName, Object headerValue) {
this.headerAccessor.setHeaderIfAbsent(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 removeHeaders(String... headerPatterns) {
this.headerAccessor.removeHeaders(headerPatterns);
return this;
}
/**
* Remove the value for the given header name.
*/
public MessageBuilder removeHeader(String headerName) {
this.headerAccessor.removeHeader(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 copyHeaders(@Nullable Map headersToCopy) {
this.headerAccessor.copyHeaders(headersToCopy);
return this;
}
/**
* Copy the name-value pairs from the provided Map. This operation will not
* overwrite any existing values.
*/
public MessageBuilder copyHeadersIfAbsent(@Nullable Map headersToCopy) {
this.headerAccessor.copyHeadersIfAbsent(headersToCopy);
return this;
}
public MessageBuilder setReplyChannel(MessageChannel replyChannel) {
this.headerAccessor.setReplyChannel(replyChannel);
return this;
}
public MessageBuilder setReplyChannelName(String replyChannelName) {
this.headerAccessor.setReplyChannelName(replyChannelName);
return this;
}
public MessageBuilder setErrorChannel(MessageChannel errorChannel) {
this.headerAccessor.setErrorChannel(errorChannel);
return this;
}
public MessageBuilder setErrorChannelName(String errorChannelName) {
this.headerAccessor.setErrorChannelName(errorChannelName);
return this;
}
@SuppressWarnings("unchecked")
public Message build() {
if (this.providedMessage != null && !this.headerAccessor.isModified()) {
return this.providedMessage;
}
MessageHeaders headersToUse = this.headerAccessor.toMessageHeaders();
if (this.payload instanceof Throwable) {
if (this.providedMessage != null && this.providedMessage instanceof ErrorMessage) {
Message message = ((ErrorMessage) this.providedMessage).getOriginalMessage();
if (message != null) {
return (Message) new ErrorMessage((Throwable) this.payload, headersToUse, message);
}
}
return (Message) new ErrorMessage((Throwable) this.payload, headersToUse);
}
else {
return new GenericMessage<>(this.payload, headersToUse);
}
}
/**
* 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.
* If the provided message is an {@link ErrorMessage}, the
* {@link ErrorMessage#getOriginalMessage() originalMessage} it contains, will be
* passed on to new instance.
* @param message the Message from which the payload and all headers will be copied
*/
public static MessageBuilder fromMessage(Message message) {
return new MessageBuilder<>(message);
}
/**
* Create a new builder for a message with the given payload.
* @param payload the payload
*/
public static MessageBuilder withPayload(T payload) {
return new MessageBuilder<>(payload, new MessageHeaderAccessor());
}
/**
* A shortcut factory method for creating a message with the given payload
* and {@code MessageHeaders}.
* Note: the given {@code MessageHeaders} instance is used
* directly in the new message, i.e. it is not copied.
* @param payload the payload to use (never {@code null})
* @param messageHeaders the headers to use (never {@code null})
* @return the created message
* @since 4.1
*/
@SuppressWarnings("unchecked")
public static Message createMessage(@Nullable T payload, MessageHeaders messageHeaders) {
Assert.notNull(payload, "Payload must not be null");
Assert.notNull(messageHeaders, "MessageHeaders must not be null");
if (payload instanceof Throwable) {
return (Message) new ErrorMessage((Throwable) payload, messageHeaders);
}
else {
return new GenericMessage<>(payload, messageHeaders);
}
}
}