Class WebsocketHandlerDecorator

java.lang.Object

io.fluxzero.sdk.web.WebsocketHandlerDecorator

All Implemented Interfaces:

ParameterResolver<HasMessage>, HandlerDecorator

public class WebsocketHandlerDecorator
extends Object
implements HandlerDecorator, ParameterResolver<HasMessage>

Decorator that adds WebSocket session support to handler classes and enables parameter injection for SocketSession.

This decorator supports @HandleWeb-annotated methods that interact over WebSocket connections, and transparently manages the lifecycle of SocketSession instances. It implements both HandlerDecorator and ParameterResolver to provide the following capabilities:

• Automatically upgrades incoming WS_HANDSHAKE requests to WebSocket sessions if the handler includes methods annotated with HandleSocketOpen or similar, but does not explicitly handle the handshake itself. This ensures that endpoints which declare websocket handlers still result in a successful connection upgrade even without a dedicated handshake method.
• Delegates WS_MESSAGE requests to the associated SocketSession for message dispatch and response.
• Performs cleanup on WS_CLOSE requests, closing the session and invoking any associated HandleSocketClose handlers.
• Resolves SocketSession method parameters in applicable WebSocket handler methods.

This decorator also tracks open WebSocket sessions and ensures that message dispatch is session-aware. It works transparently with the Fluxzero client’s message routing and tracking infrastructure.

Nested Class Summary

Nested classes/interfaces inherited from interface HandlerDecorator

HandlerDecorator.MergedDecorator

Field Summary

Fields inherited from interface HandlerDecorator

noOp

Constructor Summary

Constructors

Constructor	Description
WebsocketHandlerDecorator()

Method Summary

Modifier and Type	Method	Description
protected Handler<DeserializingMessage>	cleanUpOnClose(Handler<DeserializingMessage> handler)
protected Handler<DeserializingMessage>	closeOnError(Handler<DeserializingMessage> handler)
protected Handler<DeserializingMessage>	enableHandshake(Handler<DeserializingMessage> handler, List<WebPattern> socketPatterns)
protected DefaultSocketSession	getOrCreateSocketSession(HasMessage m)
protected Handler<DeserializingMessage>	handleRequest(Handler<DeserializingMessage> handler)
boolean	matches(Parameter parameter, Annotation methodAnnotation, HasMessage value)	Determines whether this resolver supports injecting a SocketSession for the given method parameter.
boolean	mayApply(Executable method, Class<?> targetClass)	Returns true if this resolver might apply to the given method.
protected void	onAbort(DefaultSocketSession session, int code)
Function<HasMessage, Object>	resolve(Parameter p, Annotation methodAnnotation)	Resolves a SocketSession parameter from the current HasMessage context.
Handler<DeserializingMessage>	wrap(Handler<DeserializingMessage> handler)	Wraps a websocket-compatible handler with websocket-specific functionality.

Methods inherited from class Object

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

Methods inherited from interface HandlerDecorator

andThen

Methods inherited from interface ParameterResolver

determinesSpecificity, test

Constructor Details

WebsocketHandlerDecorator

public WebsocketHandlerDecorator()

Method Details

resolve

public Function<HasMessage, Object> resolve(Parameter p,
 Annotation methodAnnotation)

Resolves a SocketSession parameter from the current HasMessage context.

The session is tracked per session ID and reused for subsequent requests over the same connection. If no session exists for the current message's session ID, a new one is created.

Specified by:

resolve in interface ParameterResolver<HasMessage>

Parameters:

p - the method parameter being resolved

methodAnnotation - the handler method's annotation (e.g. @HandleWeb)

Returns:

a function that resolves the SocketSession from the message

getOrCreateSocketSession

protected DefaultSocketSession getOrCreateSocketSession(HasMessage m)

matches

public boolean matches(Parameter parameter,
 Annotation methodAnnotation,
 HasMessage value)

Determines whether this resolver supports injecting a SocketSession for the given method parameter.

The parameter must be assignable from SocketSession, and the method must be annotated with HandleWeb (or a compatible meta-annotation).

Specified by:

matches in interface ParameterResolver<HasMessage>

Parameters:

parameter - the parameter being resolved

methodAnnotation - the annotation present on the handler method

value - the current message

Returns:

true if the parameter should be resolved by this resolver

mayApply

public boolean mayApply(Executable method,
 Class<?> targetClass)

Description copied from interface: ParameterResolver

Returns true if this resolver might apply to the given method. Implementations should perform only inexpensive checks and never throw.

Specified by:

mayApply in interface ParameterResolver<HasMessage>

Parameters:

method - the handler method or constructor

targetClass - the declaring or target class

Returns:

true if this resolver could apply, false otherwise

onAbort

protected void onAbort(DefaultSocketSession session,
 int code)

wrap

public Handler<DeserializingMessage> wrap(Handler<DeserializingMessage> handler)

Wraps a websocket-compatible handler with websocket-specific functionality.

If the target handler supports websocket patterns (e.g., WS_HANDSHAKE or WS_MESSAGE), it is wrapped with logic to support automatic handshake negotiation, websocket message dispatch, and session cleanup on close.

Specified by:

wrap in interface HandlerDecorator

Parameters:

handler - the original handler

Returns:

the wrapped handler with websocket support if applicable

enableHandshake

protected Handler<DeserializingMessage> enableHandshake(Handler<DeserializingMessage> handler,
 List<WebPattern> socketPatterns)

handleRequest

protected Handler<DeserializingMessage> handleRequest(Handler<DeserializingMessage> handler)

closeOnError

protected Handler<DeserializingMessage> closeOnError(Handler<DeserializingMessage> handler)

cleanUpOnClose

protected Handler<DeserializingMessage> cleanUpOnClose(Handler<DeserializingMessage> handler)