Source code
package org.springframework.web.socket.sockjs.transport.handler;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.regex.Pattern;
import org.jspecify.annotations.Nullable;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.util.MultiValueMap;
import org.springframework.util.StringUtils;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.sockjs.SockJsException;
import org.springframework.web.socket.sockjs.frame.SockJsFrame;
import org.springframework.web.socket.sockjs.frame.SockJsFrameFormat;
import org.springframework.web.socket.sockjs.transport.SockJsSession;
import org.springframework.web.socket.sockjs.transport.SockJsSessionFactory;
import org.springframework.web.socket.sockjs.transport.session.AbstractHttpSockJsSession;
import org.springframework.web.util.UriComponentsBuilder;
import org.springframework.web.util.UriUtils;
/**
* Base class for HTTP transport handlers that push messages to connected clients.
*
* @author Rossen Stoyanchev
* @since 4.0
*/
public abstract class AbstractHttpSendingTransportHandler extends AbstractTransportHandler
implements SockJsSessionFactory {
/**
* Pattern for validating callback parameter values.
*/
private static final Pattern CALLBACK_PARAM_PATTERN = Pattern.compile("[0-9A-Za-z_.]*");
@Override
public final void handleRequest(ServerHttpRequest request, ServerHttpResponse response,
WebSocketHandler wsHandler, SockJsSession wsSession) throws SockJsException {
AbstractHttpSockJsSession sockJsSession = (AbstractHttpSockJsSession) wsSession;
// https://github.com/sockjs/sockjs-client/issues/130
// sockJsSession.setAcceptedProtocol(protocol);
// Set content type before writing
response.getHeaders().setContentType(getContentType());
handleRequestInternal(request, response, sockJsSession);
}
protected void handleRequestInternal(ServerHttpRequest request, ServerHttpResponse response,
AbstractHttpSockJsSession sockJsSession) throws SockJsException {
if (sockJsSession.isNew()) {
if (logger.isDebugEnabled()) {
logger.debug(request.getMethod() + " " + request.getURI());
}
sockJsSession.handleInitialRequest(request, response, getFrameFormat(request));
}
else if (sockJsSession.isClosed()) {
if (logger.isDebugEnabled()) {
logger.debug("Connection already closed (but not removed yet) for " + sockJsSession);
}
writeFrame(SockJsFrame.closeFrameGoAway(), request, response, sockJsSession);
}
else if (!sockJsSession.isActive()) {
if (logger.isTraceEnabled()) {
logger.trace("Starting " + getTransportType() + " async request.");
}
sockJsSession.handleSuccessiveRequest(request, response, getFrameFormat(request));
}
else {
if (logger.isDebugEnabled()) {
logger.debug("Another " + getTransportType() + " connection still open for " + sockJsSession);
}
writeFrame(SockJsFrame.closeFrameAnotherConnectionOpen(), request, response, sockJsSession);
}
}
private void writeFrame(SockJsFrame frame, ServerHttpRequest request, ServerHttpResponse response,
AbstractHttpSockJsSession sockJsSession) {
String formattedFrame = getFrameFormat(request).format(frame);
try {
response.getBody().write(formattedFrame.getBytes(SockJsFrame.CHARSET));
}
catch (IOException ex) {
throw new SockJsException("Failed to send " + formattedFrame, sockJsSession.getId(), ex);
}
}
protected abstract MediaType getContentType();
protected abstract SockJsFrameFormat getFrameFormat(ServerHttpRequest request);
protected final @Nullable String getCallbackParam(ServerHttpRequest request) {
String query = request.getURI().getQuery();
MultiValueMap<String, String> params = UriComponentsBuilder.newInstance().query(query).build().getQueryParams();
String value = params.getFirst("c");
if (!StringUtils.hasLength(value)) {
return null;
}
String result = UriUtils.decode(value, StandardCharsets.UTF_8);
return (CALLBACK_PARAM_PATTERN.matcher(result).matches() ? result : null);
}
}
Run 1
The code is well-structured with clear separation of concerns: request handling, frame writing, and callback parameter validation are split into focused methods. Nesting is minimal—only one level of conditionals in handleRequestInternal, with debug logging kept short. Intent is explicit through descriptive method names and clear branching logic. Logging statements slightly lengthen the code but aid maintainability. Action granularity is mostly one action per line, though some method signatures and the getCallbackParam chain are multi-step. Reading flow follows a logical sequence from public handler to private helpers. Minor deductions: repeated logging blocks could be extracted, and getCallbackParam's query parsing is somewhat dense. Overall, highly readable with strong structure and clarity.
Run 2
The code is well-structured and readable. It has a clear purpose, with a logical organization of methods and minimal nesting. The class declaration is clean, and methods are concise, each performing a single logical action. The `handleRequestInternal` method uses a clear if-else chain with flat branching, each branch having simple logic. Comments are used sparingly and effectively, explaining non-obvious decisions (e.g., issue reference, content type). Variable names are descriptive, and line breaks improve readability. Minor deductions for the unused commented-out line and slightly long method signature lines, but overall the code is highly readable and maintainable.
Run 3
The code is well-structured with clear separation of concerns, minimal nesting, and consistent naming conventions. Each method has a single responsibility and the control flow is linear with simple conditional branches. The code is concise, averaging around 10 lines per method. The main readability weakness is the two-level nesting in the if-else blocks with logging statements, which could benefit from early returns or helper methods. Additionally, the getCallbackParam method chains multiple operations in a single expression, reducing clarity. The comments and annotations are sparse but sufficient for understanding. Overall, it is readable and maintainable code.
Run 1
Code Structure: Well-organized methods separate request dispatch, frame writing, and callback validation, with clear abstract extension points. Nesting: Shallow overall; logging checks add only one level within the session-state branches. Clarity of intent: Descriptive method and variable names make responsibilities clear, though the terse callback key "c" and commented-out protocol code require context. Code length: Appropriately concise, with some repetitive logging boilerplate and an obsolete-looking comment. Action granularity: Most lines perform one clear action; chained query parsing and frame encoding slightly increase reading effort. Reading flow: Request setup leads naturally into state-based handling, followed by supporting methods. Consistent formatting aids scanning, although the imports lack visual separation from the package declaration.
Run 2
Code Structure: Well-organized methods separate request dispatch, frame writing, callback validation, and subclass extension points. Nesting: Shallow overall, with only one additional level for logging checks inside session-state branches. Clarity of intent: Descriptive method and variable names make transport behavior clear; the callback key "c" and commented-out protocol code introduce minor ambiguity. Code length: Appropriately concise, although repeated logging guards and obsolete comments add some clutter. Action granularity: Most statements perform one clear action; chained query parsing and the validation ternary compress several operations slightly. Reading flow: Request setup naturally leads into session-state handling, with supporting helpers afterward. Consistent formatting aids scanning, though long signatures, tightly packed imports, and extra blank lines modestly reduce readability.
Run 3
Code Structure: Well-organized methods separate request dispatch, frame writing, callback validation, and subclass customization. Nesting: Shallow overall; session-state branches contain only small logging checks. Clarity of intent: Descriptive names, explicit state checks, and focused methods communicate purpose well, although the callback key "c" and commented-out protocol code introduce minor ambiguity. Code length: Concise for its responsibilities, with some repetitive logging and an obsolete-looking comment adding noise. Action granularity: Most statements perform one clear action; chained query parsing compresses several operations into one line. Reading flow: Request setup naturally leads into session-state handling, with supporting methods below. Consistent formatting supports scanning, though long signatures and the densely chained parsing statement slightly interrupt flow.