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); }
/** * 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); } }