org.springframework.messaging.simp.user

Class UserDestinationMessageHandler

java.lang.Object

org.springframework.messaging.simp.user.UserDestinationMessageHandler

All Implemented Interfaces:

Lifecycle, Phased, SmartLifecycle, MessageHandler

public class UserDestinationMessageHandler
extends java.lang.Object
implements MessageHandler, SmartLifecycle

MessageHandler with support for "user" destinations.

Listens for messages with "user" destinations, translates their destination to actual target destinations unique to the active session(s) of a user, and then sends the resolved messages to the broker channel to be delivered.

Since:

4.0

Author:

Rossen Stoyanchev

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	UserDestinationMessageHandler.BroadcastHandler A handler that broadcasts locally unresolved messages to the broker and also handles similar broadcasts received from the broker.

Field Summary

Fields

Modifier and Type	Field and Description
private UserDestinationMessageHandler.BroadcastHandler	broadcastHandler
private SubscribableChannel	brokerChannel
private SubscribableChannel	clientInboundChannel
private UserDestinationResolver	destinationResolver
private MessageHeaderInitializer	headerInitializer
private java.lang.Object	lifecycleMonitor
private static Log	logger
private MessageSendingOperations<java.lang.String>	messagingTemplate
private boolean	running

Constructor Summary

Constructors

Constructor and Description
UserDestinationMessageHandler(SubscribableChannel clientInboundChannel, SubscribableChannel brokerChannel, UserDestinationResolver resolver) Create an instance with the given client and broker channels subscribing to handle messages from each and then sending any resolved messages to the broker channel.

Method Summary

Modifier and Type	Method and Description
java.lang.String	getBroadcastDestination() Return the configured destination for unresolved messages.
MessageSendingOperations<java.lang.String>	getBrokerMessagingTemplate() Return the messaging template used to send resolved messages to the broker channel.
MessageHeaderInitializer	getHeaderInitializer() Return the configured header initializer.
int	getPhase() Return the phase value of this object.
UserDestinationResolver	getUserDestinationResolver() Return the configured UserDestinationResolver.
void	handleMessage(Message<?> message) Handle the given message.
private void	initHeaders(SimpMessageHeaderAccessor headerAccessor)
boolean	isAutoStartup() Returns true if this Lifecycle component should get started automatically by the container at the time that the containing ApplicationContext gets refreshed.
boolean	isRunning() Check whether this component is currently running.
void	setBroadcastDestination(java.lang.String destination) Set a destination to broadcast messages to that remain unresolved because the user is not connected.
void	setHeaderInitializer(MessageHeaderInitializer headerInitializer) Configure a custom MessageHeaderInitializer to initialize the headers of resolved target messages.
void	start() Start this component.
void	stop() Stop this component, typically in a synchronous fashion, such that the component is fully stopped upon return of this method.
void	stop(java.lang.Runnable callback) Indicates that a Lifecycle component must stop if it is currently running.
java.lang.String	toString()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

logger

private static final Log logger

clientInboundChannel

private final SubscribableChannel clientInboundChannel

brokerChannel

private final SubscribableChannel brokerChannel

destinationResolver

private final UserDestinationResolver destinationResolver

messagingTemplate

private final MessageSendingOperations<java.lang.String> messagingTemplate

broadcastHandler

private UserDestinationMessageHandler.BroadcastHandler broadcastHandler

headerInitializer

private MessageHeaderInitializer headerInitializer

lifecycleMonitor

private final java.lang.Object lifecycleMonitor

running

private volatile boolean running

Constructor Detail

UserDestinationMessageHandler

public UserDestinationMessageHandler(SubscribableChannel clientInboundChannel,
                                     SubscribableChannel brokerChannel,
                                     UserDestinationResolver resolver)

Create an instance with the given client and broker channels subscribing to handle messages from each and then sending any resolved messages to the broker channel.

Parameters:

clientInboundChannel - messages received from clients.

brokerChannel - messages sent to the broker.

resolver - the resolver for "user" destinations.

Method Detail

getUserDestinationResolver

public UserDestinationResolver getUserDestinationResolver()

Return the configured UserDestinationResolver.

setBroadcastDestination

public void setBroadcastDestination(java.lang.String destination)

Set a destination to broadcast messages to that remain unresolved because the user is not connected. In a multi-application server scenario this gives other application servers a chance to try.

By default this is not set.

Parameters:

destination - the target destination.

getBroadcastDestination

public java.lang.String getBroadcastDestination()

Return the configured destination for unresolved messages.

getBrokerMessagingTemplate

public MessageSendingOperations<java.lang.String> getBrokerMessagingTemplate()

Return the messaging template used to send resolved messages to the broker channel.

setHeaderInitializer

public void setHeaderInitializer(MessageHeaderInitializer headerInitializer)

Configure a custom MessageHeaderInitializer to initialize the headers of resolved target messages.

By default this is not set.

getHeaderInitializer

public MessageHeaderInitializer getHeaderInitializer()

Return the configured header initializer.

getPhase

public int getPhase()

Description copied from interface: Phased

Return the phase value of this object.

Specified by:

getPhase in interface Phased

isAutoStartup

public boolean isAutoStartup()

Description copied from interface: SmartLifecycle

Returns true if this Lifecycle component should get started automatically by the container at the time that the containing ApplicationContext gets refreshed.

A value of false indicates that the component is intended to be started through an explicit Lifecycle.start() call instead, analogous to a plain Lifecycle implementation.

Specified by:

isAutoStartup in interface SmartLifecycle

See Also:

Lifecycle.start(), Phased.getPhase(), LifecycleProcessor.onRefresh(), ConfigurableApplicationContext.refresh()

isRunning

public final boolean isRunning()

Description copied from interface: Lifecycle

Check whether this component is currently running.

In the case of a container, this will return true only if all components that apply are currently running.

Specified by:

isRunning in interface Lifecycle

Returns:

whether the component is currently running

start

public final void start()

Description copied from interface: Lifecycle

Start this component.

Should not throw an exception if the component is already running.

In the case of a container, this will propagate the start signal to all components that apply.

Specified by:

start in interface Lifecycle

See Also:

SmartLifecycle.isAutoStartup()

stop

public final void stop()

Description copied from interface: Lifecycle

Stop this component, typically in a synchronous fashion, such that the component is fully stopped upon return of this method. Consider implementing SmartLifecycle and its stop(Runnable) variant when asynchronous stop behavior is necessary.

Note that this stop notification is not guaranteed to come before destruction: On regular shutdown, Lifecycle beans will first receive a stop notification before the general destruction callbacks are being propagated; however, on hot refresh during a context's lifetime or on aborted refresh attempts, only destroy methods will be called.

Should not throw an exception if the component isn't started yet.

In the case of a container, this will propagate the stop signal to all components that apply.

Specified by:

stop in interface Lifecycle

See Also:

SmartLifecycle.stop(Runnable), DisposableBean.destroy()

stop

public final void stop(java.lang.Runnable callback)

Description copied from interface: SmartLifecycle

Indicates that a Lifecycle component must stop if it is currently running.

The provided callback is used by the LifecycleProcessor to support an ordered, and potentially concurrent, shutdown of all components having a common shutdown order value. The callback must be executed after the SmartLifecycle component does indeed stop.

The LifecycleProcessor will call only this variant of the stop method; i.e. Lifecycle.stop() will not be called for SmartLifecycle implementations unless explicitly delegated to within the implementation of this method.

Specified by:

stop in interface SmartLifecycle

See Also:

Lifecycle.stop(), Phased.getPhase()

handleMessage

public void handleMessage(Message<?> message)
                   throws MessagingException

Description copied from interface: MessageHandler

Handle the given message.

Specified by:

handleMessage in interface MessageHandler

Parameters:

message - the message to be handled

Throws:

MessagingException

initHeaders

private void initHeaders(SimpMessageHeaderAccessor headerAccessor)

toString

public java.lang.String toString()

Overrides:

toString in class java.lang.Object