Example usage for org.springframework.messaging.support MessageHeaderAccessor getAccessor

List of usage examples for org.springframework.messaging.support MessageHeaderAccessor getAccessor

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.messaging.support.*
  5. MessageHeaderAccessor
  6. getAccessor

Introduction

In this page you can find the example usage for org.springframework.messaging.support MessageHeaderAccessor getAccessor.

Prototype

@SuppressWarnings("unchecked")
@Nullable
public static <T extends MessageHeaderAccessor> T getAccessor(MessageHeaders messageHeaders,
        @Nullable Class<T> requiredType)

Source Link

Document

A variation of #getAccessor(org.springframework.messaging.Message,Class) with a MessageHeaders instance instead of a Message .

Usage

From source file:org.eclipse.hawkbit.event.BusProtoStuffMessageConverter.java

private static boolean isAccessorMutable(final MessageHeaders headers) {
    final MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(headers,
            MessageHeaderAccessor.class);
    return accessor != null && accessor.isMutable();
}

From source file:org.springframework.messaging.converter.AbstractMessageConverter.java

@Override
@Nullable/*from   ww  w.  j  a  v a  2 s . co  m*/
public final Message<?> toMessage(Object payload, @Nullable MessageHeaders headers,
        @Nullable Object conversionHint) {
    if (!canConvertTo(payload, headers)) {
        return null;
    }

    Object payloadToUse = convertToInternal(payload, headers, conversionHint);
    if (payloadToUse == null) {
        return null;
    }

    MimeType mimeType = getDefaultContentType(payloadToUse);
    if (headers != null) {
        MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(headers,
                MessageHeaderAccessor.class);
        if (accessor != null && accessor.isMutable()) {
            if (mimeType != null) {
                accessor.setHeaderIfAbsent(MessageHeaders.CONTENT_TYPE, mimeType);
            }
            return MessageBuilder.createMessage(payloadToUse, accessor.getMessageHeaders());
        }
    }

    MessageBuilder<?> builder = MessageBuilder.withPayload(payloadToUse);
    if (headers != null) {
        builder.copyHeaders(headers);
    }
    if (mimeType != null) {
        builder.setHeaderIfAbsent(MessageHeaders.CONTENT_TYPE, mimeType);
    }
    return builder.build();
}

From source file:org.springframework.messaging.core.GenericMessagingTemplate.java

protected final void doSend(MessageChannel channel, Message<?> message, long timeout) {
    Assert.notNull(channel, "MessageChannel is required");

    Message<?> messageToSend = message;
    MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class);
    if (accessor != null && accessor.isMutable()) {
        accessor.removeHeader(this.sendTimeoutHeader);
        accessor.removeHeader(this.receiveTimeoutHeader);
        accessor.setImmutable();// ww  w  .j  a v a2 s.c om
    } else if (message.getHeaders().containsKey(this.sendTimeoutHeader)
            || message.getHeaders().containsKey(this.receiveTimeoutHeader)) {
        messageToSend = MessageBuilder.fromMessage(message).setHeader(this.sendTimeoutHeader, null)
                .setHeader(this.receiveTimeoutHeader, null).build();
    }

    boolean sent = (timeout >= 0 ? channel.send(messageToSend, timeout) : channel.send(messageToSend));

    if (!sent) {
        throw new MessageDeliveryException(message,
                "Failed to send message to channel '" + channel + "' within timeout: " + timeout);
    }
}

From source file:org.springframework.messaging.simp.annotation.support.SimpAnnotationMethodMessageHandler.java

@Override
protected void handleMatch(SimpMessageMappingInfo mapping, HandlerMethod handlerMethod,
        String lookupDestination, Message<?> message) {

    Set<String> patterns = mapping.getDestinationConditions().getPatterns();
    if (!CollectionUtils.isEmpty(patterns)) {
        String pattern = patterns.iterator().next();
        Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(pattern, lookupDestination);
        if (!CollectionUtils.isEmpty(vars)) {
            MessageHeaderAccessor mha = MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class);
            Assert.state(mha != null && mha.isMutable(), "Mutable MessageHeaderAccessor required");
            mha.setHeader(DestinationVariableMethodArgumentResolver.DESTINATION_TEMPLATE_VARIABLES_HEADER,
                    vars);//  w  ww .ja  va  2  s .co m
        }
    }

    try {
        SimpAttributesContextHolder.setAttributesFromMessage(message);
        super.handleMatch(mapping, handlerMethod, lookupDestination, message);
    } finally {
        SimpAttributesContextHolder.resetAttributes();
    }
}

From source file:org.springframework.messaging.simp.broker.OrderedMessageSender.java

private void addCompletionCallback(Message<?> msg) {
    SimpMessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(msg,
            SimpMessageHeaderAccessor.class);
    Assert.isTrue(accessor != null && accessor.isMutable(), "Expected mutable SimpMessageHeaderAccessor");
    accessor.setHeader(COMPLETION_TASK_HEADER, (Runnable) this::sendNextMessage);
}

From source file:org.springframework.messaging.simp.stomp.DefaultStompSession.java

private void execute(Message<byte[]> message) {
    if (logger.isTraceEnabled()) {
        StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
        if (accessor != null) {
            logger.trace("Sending " + accessor.getDetailedLogMessage(message.getPayload()));
        }//www.  java 2s .  c  o m
    }
    TcpConnection<byte[]> conn = this.connection;
    Assert.state(conn != null, "Connection closed");
    try {
        conn.send(message).get();
    } catch (ExecutionException ex) {
        throw new MessageDeliveryException(message, ex.getCause());
    } catch (Throwable ex) {
        throw new MessageDeliveryException(message, ex);
    }
}

From source file:org.springframework.messaging.simp.stomp.DefaultStompSession.java

@Override
public void handleMessage(Message<byte[]> message) {
    StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
    Assert.state(accessor != null, "No StompHeaderAccessor");

    accessor.setSessionId(this.sessionId);
    StompCommand command = accessor.getCommand();
    Map<String, List<String>> nativeHeaders = accessor.getNativeHeaders();
    StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(nativeHeaders);
    boolean isHeartbeat = accessor.isHeartbeat();
    if (logger.isTraceEnabled()) {
        logger.trace("Received " + accessor.getDetailedLogMessage(message.getPayload()));
    }/* ww  w  .  j a va 2s. c o  m*/

    try {
        if (StompCommand.MESSAGE.equals(command)) {
            DefaultSubscription subscription = this.subscriptions.get(stompHeaders.getSubscription());
            if (subscription != null) {
                invokeHandler(subscription.getHandler(), message, stompHeaders);
            } else if (logger.isDebugEnabled()) {
                logger.debug("No handler for: " + accessor.getDetailedLogMessage(message.getPayload())
                        + ". Perhaps just unsubscribed?");
            }
        } else {
            if (StompCommand.RECEIPT.equals(command)) {
                String receiptId = stompHeaders.getReceiptId();
                ReceiptHandler handler = this.receiptHandlers.get(receiptId);
                if (handler != null) {
                    handler.handleReceiptReceived();
                } else if (logger.isDebugEnabled()) {
                    logger.debug(
                            "No matching receipt: " + accessor.getDetailedLogMessage(message.getPayload()));
                }
            } else if (StompCommand.CONNECTED.equals(command)) {
                initHeartbeatTasks(stompHeaders);
                this.version = stompHeaders.getFirst("version");
                this.sessionFuture.set(this);
                this.sessionHandler.afterConnected(this, stompHeaders);
            } else if (StompCommand.ERROR.equals(command)) {
                invokeHandler(this.sessionHandler, message, stompHeaders);
            } else if (!isHeartbeat && logger.isTraceEnabled()) {
                logger.trace("Message not handled.");
            }
        }
    } catch (Throwable ex) {
        this.sessionHandler.handleException(this, command, stompHeaders, message.getPayload(), ex);
    }
}

From source file:org.springframework.web.socket.messaging.StompSubProtocolHandler.java

/**
 * Handle incoming WebSocket messages from clients.
 *//*from  ww w.j a v a2s . com*/
public void handleMessageFromClient(WebSocketSession session, WebSocketMessage<?> webSocketMessage,
        MessageChannel outputChannel) {

    List<Message<byte[]>> messages;
    try {
        ByteBuffer byteBuffer;
        if (webSocketMessage instanceof TextMessage) {
            byteBuffer = ByteBuffer.wrap(((TextMessage) webSocketMessage).asBytes());
        } else if (webSocketMessage instanceof BinaryMessage) {
            byteBuffer = ((BinaryMessage) webSocketMessage).getPayload();
        } else {
            return;
        }

        BufferingStompDecoder decoder = this.decoders.get(session.getId());
        if (decoder == null) {
            throw new IllegalStateException("No decoder for session id '" + session.getId() + "'");
        }

        messages = decoder.decode(byteBuffer);
        if (messages.isEmpty()) {
            if (logger.isTraceEnabled()) {
                logger.trace("Incomplete STOMP frame content received in session " + session + ", bufferSize="
                        + decoder.getBufferSize() + ", bufferSizeLimit=" + decoder.getBufferSizeLimit() + ".");
            }
            return;
        }
    } catch (Throwable ex) {
        if (logger.isErrorEnabled()) {
            logger.error("Failed to parse " + webSocketMessage + " in session " + session.getId()
                    + ". Sending STOMP ERROR to client.", ex);
        }
        handleError(session, ex, null);
        return;
    }

    for (Message<byte[]> message : messages) {
        try {
            StompHeaderAccessor headerAccessor = MessageHeaderAccessor.getAccessor(message,
                    StompHeaderAccessor.class);
            Assert.state(headerAccessor != null, "No StompHeaderAccessor");

            headerAccessor.setSessionId(session.getId());
            headerAccessor.setSessionAttributes(session.getAttributes());
            headerAccessor.setUser(getUser(session));
            headerAccessor.setHeader(SimpMessageHeaderAccessor.HEART_BEAT_HEADER,
                    headerAccessor.getHeartbeat());
            if (!detectImmutableMessageInterceptor(outputChannel)) {
                headerAccessor.setImmutable();
            }

            if (logger.isTraceEnabled()) {
                logger.trace("From client: " + headerAccessor.getShortLogMessage(message.getPayload()));
            }

            StompCommand command = headerAccessor.getCommand();
            boolean isConnect = StompCommand.CONNECT.equals(command);
            if (isConnect) {
                this.stats.incrementConnectCount();
            } else if (StompCommand.DISCONNECT.equals(command)) {
                this.stats.incrementDisconnectCount();
            }

            try {
                SimpAttributesContextHolder.setAttributesFromMessage(message);
                boolean sent = outputChannel.send(message);

                if (sent) {
                    if (isConnect) {
                        Principal user = headerAccessor.getUser();
                        if (user != null && user != session.getPrincipal()) {
                            this.stompAuthentications.put(session.getId(), user);
                        }
                    }
                    if (this.eventPublisher != null) {
                        Principal user = getUser(session);
                        if (isConnect) {
                            publishEvent(this.eventPublisher, new SessionConnectEvent(this, message, user));
                        } else if (StompCommand.SUBSCRIBE.equals(command)) {
                            publishEvent(this.eventPublisher, new SessionSubscribeEvent(this, message, user));
                        } else if (StompCommand.UNSUBSCRIBE.equals(command)) {
                            publishEvent(this.eventPublisher, new SessionUnsubscribeEvent(this, message, user));
                        }
                    }
                }
            } finally {
                SimpAttributesContextHolder.resetAttributes();
            }
        } catch (Throwable ex) {
            if (logger.isErrorEnabled()) {
                logger.error("Failed to send client message to application via MessageChannel" + " in session "
                        + session.getId() + ". Sending STOMP ERROR to client.", ex);
            }
            handleError(session, ex, message);
        }
    }
}

From source file:org.springframework.web.socket.messaging.StompSubProtocolHandler.java

private void handleError(WebSocketSession session, Throwable ex, @Nullable Message<byte[]> clientMessage) {
    if (getErrorHandler() == null) {
        sendErrorMessage(session, ex);//  w w  w  . j a v a 2  s  . com
        return;
    }

    Message<byte[]> message = getErrorHandler().handleClientMessageProcessingError(clientMessage, ex);
    if (message == null) {
        return;
    }

    StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
    Assert.state(accessor != null, "No StompHeaderAccessor");
    sendToClient(session, accessor, message.getPayload());
}

From source file:org.springframework.web.socket.messaging.StompSubProtocolHandler.java

/**
 * Handle STOMP messages going back out to WebSocket clients.
 *//*from ww w. j  a v a2s . c o m*/
@Override
@SuppressWarnings("unchecked")
public void handleMessageToClient(WebSocketSession session, Message<?> message) {
    if (!(message.getPayload() instanceof byte[])) {
        if (logger.isErrorEnabled()) {
            logger.error("Expected byte[] payload. Ignoring " + message + ".");
        }
        return;
    }

    StompHeaderAccessor accessor = getStompHeaderAccessor(message);
    StompCommand command = accessor.getCommand();

    if (StompCommand.MESSAGE.equals(command)) {
        if (accessor.getSubscriptionId() == null && logger.isWarnEnabled()) {
            logger.warn("No STOMP \"subscription\" header in " + message);
        }
        String origDestination = accessor.getFirstNativeHeader(SimpMessageHeaderAccessor.ORIGINAL_DESTINATION);
        if (origDestination != null) {
            accessor = toMutableAccessor(accessor, message);
            accessor.removeNativeHeader(SimpMessageHeaderAccessor.ORIGINAL_DESTINATION);
            accessor.setDestination(origDestination);
        }
    } else if (StompCommand.CONNECTED.equals(command)) {
        this.stats.incrementConnectedCount();
        accessor = afterStompSessionConnected(message, accessor, session);
        if (this.eventPublisher != null && StompCommand.CONNECTED.equals(command)) {
            try {
                SimpAttributes simpAttributes = new SimpAttributes(session.getId(), session.getAttributes());
                SimpAttributesContextHolder.setAttributes(simpAttributes);
                Principal user = getUser(session);
                publishEvent(this.eventPublisher,
                        new SessionConnectedEvent(this, (Message<byte[]>) message, user));
            } finally {
                SimpAttributesContextHolder.resetAttributes();
            }
        }
    }

    byte[] payload = (byte[]) message.getPayload();
    if (StompCommand.ERROR.equals(command) && getErrorHandler() != null) {
        Message<byte[]> errorMessage = getErrorHandler().handleErrorMessageToClient((Message<byte[]>) message);
        if (errorMessage != null) {
            accessor = MessageHeaderAccessor.getAccessor(errorMessage, StompHeaderAccessor.class);
            Assert.state(accessor != null, "No StompHeaderAccessor");
            payload = errorMessage.getPayload();
        }
    }
    sendToClient(session, accessor, payload);
}