How to use org.springframework.messaging.support

public boolean applyPreReceive(MessageChannel channel) {
  for (ChannelInterceptor interceptor : interceptors) {
    if (!interceptor.preReceive(channel)) {
      triggerAfterReceiveCompletion(null, channel, null);
      return false;
    }
    this.receiveInterceptorIndex++;
  }
  return true;
}

@Override
public void addInterceptor(ChannelInterceptor interceptor) {
  super.addInterceptor(interceptor);
  updateExecutorInterceptorsFor(interceptor);
}

/**
 * Return a concise message for logging purposes.
 * @param payload the payload that corresponds to the headers.
 * @return the message
 */
public String getShortLogMessage(Object payload) {
  return "headers=" + this.headers.toString() + getShortPayloadLogMessage(payload);
}

@Override
public Message<?> toMessage(Object payload, @Nullable MessageHeaders headers) {
  if (headers != null) {
    MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(headers, MessageHeaderAccessor.class);
    if (accessor != null && accessor.isMutable()) {
      return MessageBuilder.createMessage(payload, accessor.getMessageHeaders());
    }
  }
  return MessageBuilder.withPayload(payload).copyHeaders(headers).build();
}

private Message<byte[]> message(SimpMessageType messageType) {
  MessageBuilder<byte[]> builder = MessageBuilder.withPayload(new byte[0]);
  if (messageType != null) {
    builder.setHeader(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER, messageType);
  }
  return builder.build();
}

@SuppressWarnings("unchecked")
public Message<T> build() {
  if (this.originalMessage != null && !this.headerAccessor.isModified()) {
    return this.originalMessage;
  }
  MessageHeaders headersToUse = this.headerAccessor.toMessageHeaders();
  if (this.payload instanceof Throwable) {
    return (Message<T>) new ErrorMessage((Throwable) this.payload, headersToUse);
  }
  else {
    return new GenericMessage<>(this.payload, headersToUse);
  }
}

@Override
public Message<?> preSend(Message<?> message, MessageChannel channel) {
  MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class);
  if (accessor != null && accessor.isMutable()) {
    accessor.setImmutable();
  }
  return message;
}

@Override
public void initHeaders(MessageHeaderAccessor headerAccessor) {
  IdGenerator idGenerator = getIdGenerator();
  if (idGenerator != null) {
    headerAccessor.setIdGenerator(idGenerator);
  }
  headerAccessor.setEnableTimestamp(isEnableTimestamp());
}

@Before
public void setup() {
  this.channel = new ExecutorSubscribableChannel();
  this.messageHandler = new TestMessageHandler();
  this.channel.subscribe(this.messageHandler);
}

/**
 * Set the value for the given header name only if the header name is not
 * already associated with a value.
 */
public void setHeaderIfAbsent(String name, Object value) {
  if (getHeader(name) == null) {
    setHeader(name, value);
  }
}

/**
 * Create a new builder for a message with the given payload.
 * @param payload the payload
 */
public static <T> MessageBuilder<T> withPayload(T payload) {
  return new MessageBuilder<>(payload, new MessageHeaderAccessor());
}

public void applyPostSend(Message<?> message, MessageChannel channel, boolean sent) {
  for (ChannelInterceptor interceptor : interceptors) {
    interceptor.postSend(message, channel, sent);
  }
}

/**
 * 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) {
  this.headerAccessor.removeHeaders(headerPatterns);
  return this;
}
/**

/**
 * 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) {
  return new MessageBuilder<>(message);
}

/**
 * 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) {
  this.headerAccessor.setHeaderIfAbsent(headerName, headerValue);
  return this;
}

  @Override
  public Message<?> beforeHandle(Message<?> message, MessageChannel channel, MessageHandler handler) {
    super.beforeHandle(message, channel, handler);
    return null;
  }
}

  @Override
  protected TestMessageHeaderAccessor createAccessor(Message<?> message) {
    return wrap(message);
  }
}

  @Override
  public Message<?> preSend(Message<?> message, MessageChannel channel) {
    super.preSend(message, channel);
    return null;
  }
}

@Override
public void addInterceptor(int index, ChannelInterceptor interceptor) {
  super.addInterceptor(index, interceptor);
  updateExecutorInterceptorsFor(interceptor);
}

  @Override
  public Message<?> beforeHandle(Message<?> message, MessageChannel channel, MessageHandler handler) {
    super.beforeHandle(message, channel, handler);
    if (this.exceptionToRaise != null) {
      throw this.exceptionToRaise;
    }
    return (this.messageToReturn != null ? this.messageToReturn : message);
  }
}