Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Support for Jetty 10

Browse Source 
Closes gh-26123
This commit is contained in:
Rossen Stoyanchev
2021-01-21 20:16:21 +00:00
parent e537844a09
commit aa7584d252
11 changed files with 1006 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

137
spring-websocket/src/main/java/org/springframework/web/socket/adapter/jetty/Jetty10WebSocketHandlerAdapter.java Normal file
View File

@@ -0,0 +1,137 @@
/*
* Copyright 2002-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.socket.adapter.jetty;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketError;
import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
import org.eclipse.jetty.websocket.api.annotations.WebSocket;
import org.eclipse.jetty.websocket.api.extensions.Frame;
import org.springframework.util.Assert;
import org.springframework.web.socket.BinaryMessage;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.handler.ExceptionWebSocketHandlerDecorator;
/**
* Identical to {@link JettyWebSocketHandlerAdapter}, only excluding the
* {@code onWebSocketFrame} method, since the {@link Frame} argument has moved
* to a different package in Jetty 10.
*
* @author Rossen Stoyanchev
* @since 5.3.4
*/
@WebSocket
public class Jetty10WebSocketHandlerAdapter {
private static final Log logger = LogFactory.getLog(Jetty10WebSocketHandlerAdapter.class);
private final WebSocketHandler webSocketHandler;
private final JettyWebSocketSession wsSession;
public Jetty10WebSocketHandlerAdapter(WebSocketHandler webSocketHandler, JettyWebSocketSession wsSession) {
Assert.notNull(webSocketHandler, "WebSocketHandler must not be null");
Assert.notNull(wsSession, "WebSocketSession must not be null");
this.webSocketHandler = webSocketHandler;
this.wsSession = wsSession;
}
@OnWebSocketConnect
public void onWebSocketConnect(Session session) {
try {
this.wsSession.initializeNativeSession(session);
this.webSocketHandler.afterConnectionEstablished(this.wsSession);
}
catch (Exception ex) {
ExceptionWebSocketHandlerDecorator.tryCloseWithError(this.wsSession, ex, logger);
}
}
@OnWebSocketMessage
public void onWebSocketText(String payload) {
TextMessage message = new TextMessage(payload);
try {
this.webSocketHandler.handleMessage(this.wsSession, message);
}
catch (Exception ex) {
ExceptionWebSocketHandlerDecorator.tryCloseWithError(this.wsSession, ex, logger);
}
}
@OnWebSocketMessage
public void onWebSocketBinary(byte[] payload, int offset, int length) {
BinaryMessage message = new BinaryMessage(payload, offset, length, true);
try {
this.webSocketHandler.handleMessage(this.wsSession, message);
}
catch (Exception ex) {
ExceptionWebSocketHandlerDecorator.tryCloseWithError(this.wsSession, ex, logger);
}
}
// TODO: onWebSocketFrame can't be declared without compiling against Jetty 10
// Jetty 10: org.eclipse.jetty.websocket.api.Frame
// Jetty 9: org.eclipse.jetty.websocket.api.extensions.Frame
// @OnWebSocketFrame
// public void onWebSocketFrame(Frame frame) {
// if (OpCode.PONG == frame.getOpCode()) {
// ByteBuffer payload = frame.getPayload() != null ? frame.getPayload() : EMPTY_PAYLOAD;
// PongMessage message = new PongMessage(payload);
// try {
// this.webSocketHandler.handleMessage(this.wsSession, message);
// }
// catch (Exception ex) {
// ExceptionWebSocketHandlerDecorator.tryCloseWithError(this.wsSession, ex, logger);
// }
// }
// }
@OnWebSocketClose
public void onWebSocketClose(int statusCode, String reason) {
CloseStatus closeStatus = new CloseStatus(statusCode, reason);
try {
this.webSocketHandler.afterConnectionClosed(this.wsSession, closeStatus);
}
catch (Exception ex) {
if (logger.isWarnEnabled()) {
logger.warn("Unhandled exception after connection closed for " + this, ex);
}
}
}
@OnWebSocketError
public void onWebSocketError(Throwable cause) {
try {
this.webSocketHandler.handleTransportError(this.wsSession, cause);
}
catch (Exception ex) {
ExceptionWebSocketHandlerDecorator.tryCloseWithError(this.wsSession, ex, logger);
}
}
}

144
spring-websocket/src/main/java/org/springframework/web/socket/adapter/jetty/JettyWebSocketSession.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2018 the original author or authors.
* Copyright 2002-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -17,6 +17,7 @@
package org.springframework.web.socket.adapter.jetty;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.InetSocketAddress;
import java.net.URI;
import java.security.Principal;
@@ -27,13 +28,14 @@ import java.util.Map;
import org.eclipse.jetty.websocket.api.RemoteEndpoint;
import org.eclipse.jetty.websocket.api.Session;
import org.eclipse.jetty.websocket.api.WebSocketException;
import org.eclipse.jetty.websocket.api.extensions.ExtensionConfig;
import org.springframework.http.HttpHeaders;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ClassUtils;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ReflectionUtils;
import org.springframework.web.socket.BinaryMessage;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.PingMessage;
@@ -54,6 +56,12 @@ import org.springframework.web.socket.adapter.AbstractWebSocketSession;
*/
public class JettyWebSocketSession extends AbstractWebSocketSession<Session> {
private static final ClassLoader loader = JettyWebSocketSession.class.getClassLoader();
private static final boolean jetty10Present = ClassUtils.isPresent(
"org.eclipse.jetty.websocket.server.JettyWebSocketServerContainer", loader);
private final String id;
@Nullable
@@ -71,6 +79,8 @@ public class JettyWebSocketSession extends AbstractWebSocketSession<Session> {
@Nullable
private Principal user;
private final SessionHelper sessionHelper;
/**
* Create a new {@link JettyWebSocketSession} instance.
@@ -91,6 +101,7 @@ public class JettyWebSocketSession extends AbstractWebSocketSession<Session> {
super(attributes);
this.id = idGenerator.generateId().toString();
this.user = user;
this.sessionHelper = (jetty10Present ? new Jetty10SessionHelper() : new Jetty9SessionHelper());
}
@@ -141,28 +152,32 @@ public class JettyWebSocketSession extends AbstractWebSocketSession<Session> {
return getNativeSession().getRemoteAddress();
}
/**
* This method is a no-op for Jetty. As per {@link Session#getPolicy()}, the
* returned {@code WebSocketPolicy} is read-only and changing it has no effect.
*/
@Override
public void setTextMessageSizeLimit(int messageSizeLimit) {
checkNativeSessionInitialized();
getNativeSession().getPolicy().setMaxTextMessageSize(messageSizeLimit);
}
@Override
public int getTextMessageSizeLimit() {
checkNativeSessionInitialized();
return getNativeSession().getPolicy().getMaxTextMessageSize();
return this.sessionHelper.getTextMessageSizeLimit(getNativeSession());
}
/**
* This method is a no-op for Jetty. As per {@link Session#getPolicy()}, the
* returned {@code WebSocketPolicy} is read-only and changing it has no effect.
*/
@Override
public void setBinaryMessageSizeLimit(int messageSizeLimit) {
checkNativeSessionInitialized();
getNativeSession().getPolicy().setMaxBinaryMessageSize(messageSizeLimit);
}
@Override
public int getBinaryMessageSizeLimit() {
checkNativeSessionInitialized();
return getNativeSession().getPolicy().getMaxBinaryMessageSize();
return this.sessionHelper.getBinaryMessageSizeLimit(getNativeSession());
}
@Override
@@ -178,22 +193,14 @@ public class JettyWebSocketSession extends AbstractWebSocketSession<Session> {
this.uri = session.getUpgradeRequest().getRequestURI();
HttpHeaders headers = new HttpHeaders();
headers.putAll(session.getUpgradeRequest().getHeaders());
Map<String, List<String>> nativeHeaders = session.getUpgradeRequest().getHeaders();
if (!CollectionUtils.isEmpty(nativeHeaders)) {
headers.putAll(nativeHeaders);
}
this.headers = HttpHeaders.readOnlyHttpHeaders(headers);
this.acceptedProtocol = session.getUpgradeResponse().getAcceptedSubProtocol();
List<ExtensionConfig> jettyExtensions = session.getUpgradeResponse().getExtensions();
if (!CollectionUtils.isEmpty(jettyExtensions)) {
List<WebSocketExtension> extensions = new ArrayList<>(jettyExtensions.size());
for (ExtensionConfig jettyExtension : jettyExtensions) {
extensions.add(new WebSocketExtension(jettyExtension.getName(), jettyExtension.getParameters()));
}
this.extensions = Collections.unmodifiableList(extensions);
}
else {
this.extensions = Collections.emptyList();
}
this.extensions = this.sessionHelper.getExtensions(session);
if (this.user == null) {
this.user = session.getUpgradeRequest().getUserPrincipal();
@@ -221,13 +228,8 @@ public class JettyWebSocketSession extends AbstractWebSocketSession<Session> {
getRemoteEndpoint().sendPong(message.getPayload());
}
private RemoteEndpoint getRemoteEndpoint() throws IOException {
try {
return getNativeSession().getRemote();
}
catch (WebSocketException ex) {
throw new IOException("Unable to obtain RemoteEndpoint in session " + getId(), ex);
}
private RemoteEndpoint getRemoteEndpoint() {
return getNativeSession().getRemote();
}
@Override
@@ -235,4 +237,90 @@ public class JettyWebSocketSession extends AbstractWebSocketSession<Session> {
getNativeSession().close(status.getCode(), status.getReason());
}
/**
* Encapsulate incompatible changes between Jetty 9.4 and 10.
*/
private interface SessionHelper {
List<WebSocketExtension> getExtensions(Session session);
int getTextMessageSizeLimit(Session session);
int getBinaryMessageSizeLimit(Session session);
}
private static class Jetty9SessionHelper implements SessionHelper {
@Override
public List<WebSocketExtension> getExtensions(Session session) {
List<ExtensionConfig> configs = session.getUpgradeResponse().getExtensions();
if (!CollectionUtils.isEmpty(configs)) {
List<WebSocketExtension> result = new ArrayList<>(configs.size());
for (ExtensionConfig config : configs) {
result.add(new WebSocketExtension(config.getName(), config.getParameters()));
}
return Collections.unmodifiableList(result);
}
return Collections.emptyList();
}
@Override
public int getTextMessageSizeLimit(Session session) {
return session.getPolicy().getMaxTextMessageSize();
}
@Override
public int getBinaryMessageSizeLimit(Session session) {
return session.getPolicy().getMaxBinaryMessageSize();
}
}
private static class Jetty10SessionHelper implements SessionHelper {
private static final Method getTextMessageSizeLimitMethod;
private static final Method getBinaryMessageSizeLimitMethod;
static {
try {
Class<?> type = loader.loadClass("org.eclipse.jetty.websocket.api.WebSocketPolicy");
getTextMessageSizeLimitMethod = type.getMethod("getMaxTextMessageSize");
getBinaryMessageSizeLimitMethod = type.getMethod("getMaxBinaryMessageSize");
}
catch (ClassNotFoundException | NoSuchMethodException ex) {
throw new IllegalStateException("No compatible Jetty version found", ex);
}
}
// TODO: Extension info can't be accessed without compiling against Jetty 10
// Jetty 10: org.eclipse.jetty.websocket.api.ExtensionConfig
// Jetty 9: org.eclipse.jetty.websocket.api.extensions.ExtensionConfig
@Override
public List<WebSocketExtension> getExtensions(Session session) {
return Collections.emptyList();
}
// TODO: WebSocketPolicy can't be accessed without compiling against Jetty 10 (class -> interface)
@Override
@SuppressWarnings("ConstantConditions")
public int getTextMessageSizeLimit(Session session) {
long result = (long) ReflectionUtils.invokeMethod(getTextMessageSizeLimitMethod, session.getPolicy());
Assert.state(result <= Integer.MAX_VALUE, "textMessageSizeLimit is larger than Integer.MAX_VALUE");
return (int) result;
}
@Override
@SuppressWarnings("ConstantConditions")
public int getBinaryMessageSizeLimit(Session session) {
long result = (long) ReflectionUtils.invokeMethod(getBinaryMessageSizeLimitMethod, session.getPolicy());
Assert.state(result <= Integer.MAX_VALUE, "binaryMessageSizeLimit is larger than Integer.MAX_VALUE");
return (int) result;
}
}
}

88
spring-websocket/src/main/java/org/springframework/web/socket/client/jetty/JettyWebSocketClient.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2019 the original author or authors.
* Copyright 2002-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -16,6 +16,8 @@
package org.springframework.web.socket.client.jetty;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.URI;
import java.security.Principal;
import java.util.List;
@@ -34,11 +36,14 @@ import org.springframework.core.task.SimpleAsyncTaskExecutor;
import org.springframework.core.task.TaskExecutor;
import org.springframework.http.HttpHeaders;
import org.springframework.lang.Nullable;
import org.springframework.util.ClassUtils;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureTask;
import org.springframework.web.socket.WebSocketExtension;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.adapter.jetty.Jetty10WebSocketHandlerAdapter;
import org.springframework.web.socket.adapter.jetty.JettyWebSocketHandlerAdapter;
import org.springframework.web.socket.adapter.jetty.JettyWebSocketSession;
import org.springframework.web.socket.adapter.jetty.WebSocketToJettyExtensionConfigAdapter;
@@ -60,11 +65,32 @@ import org.springframework.web.util.UriComponentsBuilder;
*/
public class JettyWebSocketClient extends AbstractWebSocketClient implements Lifecycle {
private static ClassLoader loader = JettyWebSocketClient.class.getClassLoader();
private static final boolean jetty10Present;
private static final Method setHeadersMethod;
static {
jetty10Present = ClassUtils.isPresent(
"org.eclipse.jetty.websocket.client.JettyUpgradeListener", loader);
try {
setHeadersMethod = ClientUpgradeRequest.class.getMethod("setHeaders", Map.class);
}
catch (NoSuchMethodException ex) {
throw new IllegalStateException("No compatible Jetty version found", ex);
}
}
private final org.eclipse.jetty.websocket.client.WebSocketClient client;
@Nullable
private AsyncListenableTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor();
private final UpgradeHelper upgradeHelper =
(jetty10Present ? new Jetty10UpgradeHelper() : new Jetty9UpgradeHelper());
/**
* Default constructor that creates an instance of
@@ -148,14 +174,15 @@ public class JettyWebSocketClient extends AbstractWebSocketClient implements Lif
request.addExtensions(new WebSocketToJettyExtensionConfigAdapter(e));
}
headers.forEach(request::setHeader);
// Jetty 9: setHeaders declared in UpgradeRequestAdapter base class
// Jetty 10: setHeaders declared in ClientUpgradeRequest
ReflectionUtils.invokeMethod(setHeadersMethod, request, headers);
Principal user = getUser();
final JettyWebSocketSession wsSession = new JettyWebSocketSession(attributes, user);
final JettyWebSocketHandlerAdapter listener = new JettyWebSocketHandlerAdapter(wsHandler, wsSession);
JettyWebSocketSession wsSession = new JettyWebSocketSession(attributes, user);
Callable<WebSocketSession> connectTask = () -> {
Future<Session> future = this.client.connect(listener, uri, request);
Future<Session> future = this.upgradeHelper.connect(this.client, uri, request, wsHandler, wsSession);
future.get(this.client.getConnectTimeout() + 2000, TimeUnit.MILLISECONDS);
return wsSession;
};
@@ -179,4 +206,55 @@ public class JettyWebSocketClient extends AbstractWebSocketClient implements Lif
return null;
}
/**
* Encapsulate incompatible changes between Jetty 9.4 and 10.
*/
private interface UpgradeHelper {
Future<Session> connect(WebSocketClient client, URI url, ClientUpgradeRequest request,
WebSocketHandler handler, JettyWebSocketSession session) throws IOException;
}
private static class Jetty9UpgradeHelper implements UpgradeHelper {
@Override
public Future<Session> connect(WebSocketClient client, URI url, ClientUpgradeRequest request,
WebSocketHandler handler, JettyWebSocketSession session) throws IOException {
JettyWebSocketHandlerAdapter adapter = new JettyWebSocketHandlerAdapter(handler, session);
return client.connect(adapter, url, request);
}
}
private static class Jetty10UpgradeHelper implements UpgradeHelper {
// On Jetty 9 returns Future, on Jetty 10 returns CompletableFuture
private static final Method connectMethod;
static {
try {
Class<?> type = loader.loadClass("org.eclipse.jetty.websocket.client.WebSocketClient");
connectMethod = type.getMethod("connect", Object.class, URI.class, ClientUpgradeRequest.class);
}
catch (ClassNotFoundException | NoSuchMethodException ex) {
throw new IllegalStateException("No compatible Jetty version found", ex);
}
}
@Override
@SuppressWarnings({"ConstantConditions", "unchecked"})
public Future<Session> connect(WebSocketClient client, URI url, ClientUpgradeRequest request,
WebSocketHandler handler, JettyWebSocketSession session) {
Jetty10WebSocketHandlerAdapter adapter = new Jetty10WebSocketHandlerAdapter(handler, session);
// TODO: pass JettyUpgradeListener argument to set headers from HttpHeaders (like we do for Jetty 9)
// which would require a JDK Proxy since it is new in Jetty 10
return (Future<Session>) ReflectionUtils.invokeMethod(connectMethod, client, adapter, url, request);
}
}
}

165
spring-websocket/src/main/java/org/springframework/web/socket/server/jetty/Jetty10RequestUpgradeStrategy.java Normal file
View File

@@ -0,0 +1,165 @@
/*
* Copyright 2002-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.socket.server.jetty;
import java.lang.reflect.Method;
import java.lang.reflect.UndeclaredThrowableException;
import java.security.Principal;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.eclipse.jetty.websocket.server.HandshakeRFC6455;
import org.springframework.aop.framework.ProxyFactory;
import org.springframework.aop.target.EmptyTargetSource;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.http.server.ServletServerHttpResponse;
import org.springframework.lang.NonNull;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import org.springframework.util.ReflectionUtils;
import org.springframework.web.socket.WebSocketExtension;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.adapter.jetty.Jetty10WebSocketHandlerAdapter;
import org.springframework.web.socket.adapter.jetty.JettyWebSocketSession;
import org.springframework.web.socket.server.HandshakeFailureException;
import org.springframework.web.socket.server.RequestUpgradeStrategy;
/**
* A {@link RequestUpgradeStrategy} for Jetty 10.
*
* @author Rossen Stoyanchev
* @since 5.3.4
*/
public class Jetty10RequestUpgradeStrategy implements RequestUpgradeStrategy {
private static final String[] SUPPORTED_VERSIONS = new String[] { String.valueOf(HandshakeRFC6455.VERSION) };
private static final Class<?> webSocketCreatorClass;
private static final Method getContainerMethod;
private static final Method upgradeMethod;
private static final Method setAcceptedSubProtocol;
static {
ClassLoader loader = Jetty10RequestUpgradeStrategy.class.getClassLoader();
try {
webSocketCreatorClass = loader.loadClass("org.eclipse.jetty.websocket.server.JettyWebSocketCreator");
Class<?> type = loader.loadClass("org.eclipse.jetty.websocket.server.JettyWebSocketServerContainer");
getContainerMethod = type.getMethod("getContainer", ServletContext.class);
upgradeMethod = ReflectionUtils.findMethod(type, "upgrade", (Class<?>[]) null);
type = loader.loadClass("org.eclipse.jetty.websocket.server.JettyServerUpgradeResponse");
setAcceptedSubProtocol = type.getMethod("setAcceptedSubProtocol", String.class);
}
catch (Exception ex) {
throw new IllegalStateException("No compatible Jetty version found", ex);
}
}
@Override
public String[] getSupportedVersions() {
return SUPPORTED_VERSIONS;
}
@Override
public List<WebSocketExtension> getSupportedExtensions(ServerHttpRequest request) {
return Collections.emptyList();
}
@Override
public void upgrade(ServerHttpRequest request, ServerHttpResponse response,
@Nullable String selectedProtocol, List<WebSocketExtension> selectedExtensions,
@Nullable Principal user, WebSocketHandler handler, Map<String, Object> attributes)
throws HandshakeFailureException {
Assert.isInstanceOf(ServletServerHttpRequest.class, request, "ServletServerHttpRequest required");
HttpServletRequest servletRequest = ((ServletServerHttpRequest) request).getServletRequest();
ServletContext servletContext = servletRequest.getServletContext();
Assert.isInstanceOf(ServletServerHttpResponse.class, response, "ServletServerHttpResponse required");
HttpServletResponse servletResponse = ((ServletServerHttpResponse) response).getServletResponse();
JettyWebSocketSession session = new JettyWebSocketSession(attributes, user);
Jetty10WebSocketHandlerAdapter handlerAdapter = new Jetty10WebSocketHandlerAdapter(handler, session);
try {
Object creator = createJettyWebSocketCreator(handlerAdapter, selectedProtocol);
Object container = ReflectionUtils.invokeMethod(getContainerMethod, null, servletContext);
ReflectionUtils.invokeMethod(upgradeMethod, container, creator, servletRequest, servletResponse);
}
catch (UndeclaredThrowableException ex) {
throw new HandshakeFailureException("Failed to upgrade", ex.getUndeclaredThrowable());
}
catch (Exception ex) {
throw new HandshakeFailureException("Failed to upgrade", ex);
}
}
private static Object createJettyWebSocketCreator(
Jetty10WebSocketHandlerAdapter adapter, @Nullable String protocol) {
ProxyFactory factory = new ProxyFactory(EmptyTargetSource.INSTANCE);
factory.addInterface(webSocketCreatorClass);
factory.addAdvice(new WebSocketCreatorInterceptor(adapter, protocol));
return factory.getProxy();
}
/**
* Proxy for a JettyWebSocketCreator to supply the WebSocket handler and set the sub-protocol.
*/
private static class WebSocketCreatorInterceptor implements MethodInterceptor {
private final Jetty10WebSocketHandlerAdapter adapter;
@Nullable
private final String protocol;
public WebSocketCreatorInterceptor(
Jetty10WebSocketHandlerAdapter adapter, @Nullable String protocol) {
this.adapter = adapter;
this.protocol = protocol;
}
@Nullable
@Override
public Object invoke(@NonNull MethodInvocation invocation) {
if (this.protocol != null) {
ReflectionUtils.invokeMethod(
setAcceptedSubProtocol, invocation.getArguments()[2], this.protocol);
}
return this.adapter;
}
}
}

16
spring-websocket/src/main/java/org/springframework/web/socket/server/support/AbstractHandshakeHandler.java
View File

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2020 the original author or authors.
* Copyright 2002-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -71,9 +71,11 @@ import org.springframework.web.socket.server.RequestUpgradeStrategy;
*/
public abstract class AbstractHandshakeHandler implements HandshakeHandler, Lifecycle {
private static final boolean tomcatWsPresent;
private static final boolean jettyWsPresent;
private static final boolean tomcatWsPresent;
private static final boolean jetty10WsPresent;
private static final boolean undertowWsPresent;
@@ -85,10 +87,12 @@ public abstract class AbstractHandshakeHandler implements HandshakeHandler, Life
static {
ClassLoader classLoader = AbstractHandshakeHandler.class.getClassLoader();
jettyWsPresent = ClassUtils.isPresent(
"org.eclipse.jetty.websocket.server.WebSocketServerFactory", classLoader);
tomcatWsPresent = ClassUtils.isPresent(
"org.apache.tomcat.websocket.server.WsHttpUpgradeHandler", classLoader);
jetty10WsPresent = ClassUtils.isPresent(
"org.eclipse.jetty.websocket.server.JettyWebSocketServerContainer", classLoader);
jettyWsPresent = ClassUtils.isPresent(
"org.eclipse.jetty.websocket.server.WebSocketServerFactory", classLoader);
undertowWsPresent = ClassUtils.isPresent(
"io.undertow.websockets.jsr.ServerWebSocketContainer", classLoader);
glassfishWsPresent = ClassUtils.isPresent(
@@ -97,7 +101,6 @@ public abstract class AbstractHandshakeHandler implements HandshakeHandler, Life
"weblogic.websocket.tyrus.TyrusServletWriter", classLoader);
websphereWsPresent = ClassUtils.isPresent(
"com.ibm.websphere.wsoc.WsWsocServerContainer", classLoader);
}
@@ -137,6 +140,9 @@ public abstract class AbstractHandshakeHandler implements HandshakeHandler, Life
else if (jettyWsPresent) {
className = "org.springframework.web.socket.server.jetty.JettyRequestUpgradeStrategy";
}
else if (jetty10WsPresent) {
className = "org.springframework.web.socket.server.jetty.Jetty10RequestUpgradeStrategy";
}
else if (undertowWsPresent) {
className = "org.springframework.web.socket.server.standard.UndertowRequestUpgradeStrategy";
}