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 generally well-structured with clear separation of concerns and purposeful method decomposition. The handleRequest method establishes a clean flow, delegating to handleRequestInternal which uses a clear if-else chain for session states. Variable names are descriptive, and the comments explain non-obvious decisions (like the commented-out sockjs-client issue). However, there are some readability challenges: the handleRequestInternal method has repetitive logger.isDebugEnabled() checks that add noise, and the getCallbackParam method chains multiple operations in a somewhat dense manner, though each line remains focused. The abstract methods provide good extension points. The code slightly loses points for some nested logging conditions and the getCallbackParam method's compression of logic, but overall it demonstrates good practices with clear intent, reasonable line lengths, and logical organization.
Run 3
The code is well-structured with clear separation of concerns: a public handleRequest method sets content type before delegating to a protected internal handler. The internal method uses a flat if-else chain to handle session states, avoiding deep nesting. Logging statements are concise and conditional on proper log levels. Helper methods like writeFrame and getCallbackParam encapsulate single responsibilities. Each line generally performs one logical action, enhancing readability. The only minor issues are the commented-out code block and the somewhat long getCallbackParam method, but overall the code follows clean, maintainable patterns with clear naming and natural reading flow.
Run 1
Code Structure: Well-organized methods separate request dispatch, session-state handling, frame writing, and callback parsing; abstract hooks clearly mark extension points. Nesting: Shallow overall, with only logging checks nested inside state branches. Clarity of intent: Descriptive method names, explicit session predicates, and focused comments make the purpose clear, though the terse callback key "c" and commented-out protocol code add ambiguity. Code length: Appropriately concise, but repeated logging guards and obsolete comments introduce minor clutter. Action granularity: Most statements perform one action; the chained query parsing and frame encoding/writing expressions combine several operations but remain understandable. Reading flow: Request setup naturally leads into state handling and supporting helpers. Consistent formatting helps, although tightly packed imports, some extra blank lines, and long expressions slightly reduce scanability.
Run 2
Code Structure: Well-organized class with separate methods for request dispatch, frame writing, and callback parsing, plus clear abstract extension points. Nesting: Shallow overall; session-state branches contain only one additional logging conditional. Clarity of intent: Descriptive method and variable names, documentation, and explicit session-state checks make behavior clear, though the callback key "c" and commented-out protocol code need context. Code length: Appropriately concise, with minor repetition in logging guards and frame-format retrieval. Action granularity: Statements generally perform one action each; chained query parsing and the callback-validation ternary are slightly denser. Reading flow: Request setup naturally leads into state handling and supporting helpers. Consistent formatting helps, while tightly grouped imports and obsolete commented code slightly distract.
Run 3
Code Structure: Well-organized methods separate request dispatch, frame writing, callback parsing, and subclass customization. Nesting: Shallow overall; logging checks add only one level within straightforward session-state branches. Clarity of intent: Descriptive names, explicit state checks, and focused comments make behavior clear, though the callback key "c" and commented-out protocol code introduce minor ambiguity. Code length: Appropriately concise, with some repetitive logging guards and obsolete commented code. Action granularity: Most statements perform one clear action; the chained query-parsing expression packs several operations into one line. Reading flow: Request handling proceeds naturally into helper methods and extension points, supported by consistent formatting. Dense imports and a few long expressions slightly reduce scanability.