private void subscribe() { clientSession.getChannel(subscription).subscribe(this); } }
/** * <p>Equivalent to {@link #unsubscribe(ClientSessionChannel.MessageListener, ClientSession.MessageListener) * unsubscribe(listener, null)}.</p> * * @param listener the listener to unsubscribe * @return whether the unsubscribe message has been sent */ public default boolean unsubscribe(MessageListener listener) { return unsubscribe(listener, ClientSession.MessageListener.NOOP); }
/** * <p>Equivalent to {@link #handshake(Map) handshake(null)}.</p> */ default void handshake() { handshake(null); }
/** * @param listener the listener to register and invoke when a message arrives on this channel * @param callback the callback to notify of the subscribe result * @deprecated use {@link #subscribe(MessageListener, ClientSession.MessageListener)} instead */ @Deprecated public default void subscribe(MessageListener listener, MessageListener callback) { subscribe(listener, message -> callback.onMessage(this, message)); }
/** * @param template additional fields to add to the handshake message. * @param callback the message listener to notify of the handshake result * @deprecated use {@link #handshake(Map, MessageListener)} instead */ @Deprecated default void handshake(Map<String, Object> template, ClientSessionChannel.MessageListener callback) { handshake(template, message -> callback.onMessage(getChannel(Channel.META_HANDSHAKE), message)); }
/** * <p>Disconnects this session, ending the link between the client and the server peers.</p> * * @param callback the message listener to notify of the disconnect result */ void disconnect(MessageListener callback);
/** * @param listener the listener to unsubscribe * @param callback the callback to notify of the unsubscribe result * @deprecated use {@link #unsubscribe(MessageListener, ClientSession.MessageListener)} instead */ @Deprecated public default void unsubscribe(MessageListener listener, MessageListener callback) { unsubscribe(listener, message -> callback.onMessage(this, message)); }
private void processMetaHandshakeListener(Object bean) { if (bean != null) { MetaHandshakeListener listener = new MetaHandshakeListener(bean); ClientSessionChannel.MessageListener existing = handshakeListeners.putIfAbsent(bean, listener); if (existing == null) { clientSession.getChannel(Channel.META_HANDSHAKE).addListener(listener); } } }
/** * @param message the message to publish * @param callback the message callback to notify of the publish result * @deprecated use {@link #publish(Message.Mutable, ClientSession.MessageListener)} instead */ @Deprecated public default void publish(Message.Mutable message, MessageListener callback) { publish(message, m -> callback.onMessage(this, m)); }
private boolean deprocessSubscription(Object bean) { boolean result = false; List<SubscriptionCallback> callbacks = subscribers.remove(bean); if (callbacks != null) { for (SubscriptionCallback callback : callbacks) { clientSession.getChannel(callback.subscription).unsubscribe(callback); result = true; } } return result; }
/** * <p>Equivalent to {@link #subscribe(ClientSessionChannel.MessageListener, ClientSession.MessageListener) * subscribe(listener, null)}.</p> * * @param listener the listener to register and invoke when a message arrives on this channel. * @return whether the subscribe message has been sent */ public default boolean subscribe(MessageListener listener) { return subscribe(listener, ClientSession.MessageListener.NOOP); }
private void deprocessMetaHandshakeListener(Object bean) { ClientSessionChannel.MessageListener listener = handshakeListeners.remove(bean); if (listener != null) { clientSession.getChannel(Channel.META_HANDSHAKE).removeListener(listener); } }
/** * <p>Publishes the given {@code data} onto this channel.</p> * <p>The {@code data} published must not be null and can be any object that * can be natively converted to JSON (numbers, strings, arrays, lists, maps), * or objects for which a JSON converter has been registered with the * infrastructure responsible of the JSON conversion.</p> * * @param data the data to publish * @see #publish(Object, ClientSession.MessageListener) */ public default void publish(Object data) { publish(data, ClientSession.MessageListener.NOOP); }
@Override default void disconnect() { disconnect(MessageListener.NOOP); }
protected void notifyCallback(ClientSession.MessageListener callback, Message.Mutable message) { try { callback.onMessage(message); } catch (Throwable x) { _logger.info("Exception while invoking callback " + callback, x); } }
/** * @param data the data to publish * @param callback the message callback to notify of the publish result * @deprecated use {@link #publish(Object, ClientSession.MessageListener)} instead */ @Deprecated public default void publish(Object data, MessageListener callback) { publish(data, message -> callback.onMessage(this, message)); }
/** * <p>Equivalent to {@link #subscribe(Message.Mutable, MessageListener, ClientSession.MessageListener) * subscribe(null, listener, callback)}.</p> * * @param listener the listener to register and invoke when a message arrives on this channel * @param callback the callback to notify of the subscribe result * @return whether the subscribe message has been sent */ public default boolean subscribe(MessageListener listener, ClientSession.MessageListener callback) { return subscribe(null, listener, callback); }
private boolean deprocessListener(Object bean) { boolean result = false; List<ListenerCallback> callbacks = listeners.remove(bean); if (callbacks != null) { for (ListenerCallback callback : callbacks) { ClientSessionChannel channel = clientSession.getChannel(callback.subscription); if (channel != null) { channel.removeListener(callback); result = true; } } } return result; }
/** * <p>Equivalent to {@link #unsubscribe(Message.Mutable, MessageListener, ClientSession.MessageListener) * unsubscribe(null, listener, callback)}.</p> * * @param listener the listener to unsubscribe * @param callback the callback to notify of the unsubscribe result * @return whether the unsubscribe message has been sent */ public default boolean unsubscribe(MessageListener listener, ClientSession.MessageListener callback) { return unsubscribe(null, listener, callback); }
/** * <p>Equivalent to {@link #handshake(Map, ClientSession.MessageListener) handshake(template, null)}.</p> * * @param template additional fields to add to the handshake message. */ default void handshake(Map<String, Object> template) { handshake(template, MessageListener.NOOP); }