一：本文适用范围
本文使用J2EE规范原生的WebSocket开发，适用于项目中WebSocket的使用比较少的情况，而Spring WebSocket封装的比较繁重，反而不适用于实际项目中的情况。
自己在开发时就是由于项目的原因，不想用Spring-WebSocket，所有用了原生的，但是找了好多帖子试了好多方法都不行，甚至将原生的和Spring-WebSocket混用了也是不行，看源码也看了好久，最后终于解决了问题了，记录一下，也希望能帮到大家。
二：配置webSocket
我们先来看一下@ServerEndpoint注解的源码
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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
*
* http://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 javax.websocket.server;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import javax.websocket.Decoder;
import javax.websocket.Encoder;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ServerEndpoint {
/**
* URI or URI-template that the annotated class should be mapped to.
* @return The URI or URI-template that the annotated class should be mapped
* to.
*/
String value();
String[] subprotocols() default {};
Class<? extends Decoder>[] decoders() default {};
Class<? extends Encoder>[] encoders() default {};
public Class<? extends ServerEndpointConfig.Configurator> configurator()
default ServerEndpointConfig.Configurator.class;
}
package javax.websocket.server;
import java.lang.reflect.InvocationTargetException;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.ServiceLoader;
import javax.websocket.Decoder;
import javax.websocket.Encoder;
import javax.websocket.EndpointConfig;
import javax.websocket.Extension;
import javax.websocket.HandshakeResponse;
/**
* Provides configuration information for WebSocket endpoints published to a
* server. Applications may provide their own implementation or use
* {@link Builder}.
*/
public interface ServerEndpointConfig extends EndpointConfig {
......
public class Configurator {
......
public void modifyHandshake(ServerEndpointConfig sec,
HandshakeRequest request, HandshakeResponse response) {
fetchContainerDefaultConfigurator().modifyHandshake(sec, request, response);
}
......
}
}
我们看到最后的一个方法，可以看到，它要求一个ServerEndpointConfig.Configurator的子类，而Configurator类中有个modifyHandshake方法，看名字我们也应该知道这是干什么的了，我们写一个类去继承它， 并实现modifyHandshake方法从而来修改握手时的操作，将httpSession加进webSocket的配置中。
package com.demo.config.websocket;
import com.demo.exception.JMakerException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
import javax.servlet.http.HttpSession;
import javax.websocket.HandshakeResponse;
import javax.websocket.server.HandshakeRequest;
import javax.websocket.server.ServerEndpointConfig;
import java.util.Objects;
/**
* websocket核心配置
*
* @author Zany 2019/5/14
*/
@Slf4j
@Configuration
public class WebSocketConfig extends ServerEndpointConfig.Configurator {
/**
* 握手加入httpSession配置
*/
@Override
public void modifyHandshake(ServerEndpointConfig config, HandshakeRequest request, HandshakeResponse response) {
HttpSession httpSession = (HttpSession)request.getHttpSession();
if (Objects.isNull(httpSession)){
log.error("httpSession为空, header = [{}], 请登录!", request.getHeaders());
throw new JMakerException("httpSession为空, 请登录!");
}
log.debug("webSocket握手, sessionId = [{}]", httpSession.getId());
config.getUserProperties().put("httpSession", httpSession);
}
/**
* 如果不是spring boot项目，那就不需要进行这样的配置，
* 因为在tomcat中运行的话，tomcat会扫描带有@ServerEndpoint的注解成为websocket，
* 而spring boot项目中需要由这个bean来提供注册管理。
*/
@Bean
public ServerEndpointExporter serverEndpointExporter() {
return new ServerEndpointExporter();
}
}注：本来还担心用了spring-session-redis，从HandshakeRequest中getHttpSession()时，会不会有问题，看了源码之后就放心了，下面源码可以看到在构造HandshakeRequest时用的HttpServletRequest.getSession(false)，不会创建新的session，程序运行之后证明也是的。
package org.apache.tomcat.websocket.server;
import java.net.URI;
import java.net.URISyntaxException;
import java.security.Principal;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import javax.servlet.http.HttpServletRequest;
import javax.websocket.server.HandshakeRequest;
import org.apache.tomcat.util.collections.CaseInsensitiveKeyMap;
import org.apache.tomcat.util.res.StringManager;
/**
* Represents the request that this session was opened under.
*/
public class WsHandshakeRequest implements HandshakeRequest {
private static final StringManager sm = StringManager.getManager(WsHandshakeRequest.class);
private final URI requestUri;
private final Map<String,List<String>> parameterMap;
private final String queryString;
private final Principal userPrincipal;
private final Map<String,List<String>> headers;
private final Object httpSession;
private volatile HttpServletRequest request;
public WsHandshakeRequest(HttpServletRequest request, Map<String,String> pathParams) {
this.request = request;
queryString = request.getQueryString();
userPrincipal = request.getUserPrincipal();
httpSession = request.getSession(false);
requestUri = buildRequestUri(request);
// ParameterMap
Map<String,String[]> originalParameters = request.getParameterMap();
Map<String,List<String>> newParameters =
new HashMap<>(originalParameters.size());
for (Entry<String,String[]> entry : originalParameters.entrySet()) {
newParameters.put(entry.getKey(),
Collections.unmodifiableList(
Arrays.asList(entry.getValue())));
}
for (Entry<String,String> entry : pathParams.entrySet()) {
newParameters.put(entry.getKey(),
Collections.unmodifiableList(
Arrays.asList(entry.getValue())));
}
parameterMap = Collections.unmodifiableMap(newParameters);
// Headers
Map<String,List<String>> newHeaders = new CaseInsensitiveKeyMap<>();
Enumeration<String> headerNames = request.getHeaderNames();
while (headerNames.hasMoreElements()) {
String headerName = headerNames.nextElement();
newHeaders.put(headerName, Collections.unmodifiableList(
Collections.list(request.getHeaders(headerName))));
}
headers = Collections.unmodifiableMap(newHeaders);
}
@Override
public URI getRequestURI() {
return requestUri;
}
@Override
public Map<String,List<String>> getParameterMap() {
return parameterMap;
}
@Override
public String getQueryString() {
return queryString;
}
@Override
public Principal getUserPrincipal() {
return userPrincipal;
}
@Override
public Map<String,List<String>> getHeaders() {
return headers;
}
@Override
public boolean isUserInRole(String role) {
if (request == null) {
throw new IllegalStateException();
}
return request.isUserInRole(role);
}
@Override
public Object getHttpSession() {
return httpSession;
}
/**
* Called when the HandshakeRequest is no longer required. Since an instance
* of this class retains a reference to the current HttpServletRequest that
* reference needs to be cleared as the HttpServletRequest may be reused.
*
* There is no reason for instances of this class to be accessed once the
* handshake has been completed.
*/
void finished() {
request = null;
}
/*
* See RequestUtil.getRequestURL()
*/
private static URI buildRequestUri(HttpServletRequest req) {
StringBuffer uri = new StringBuffer();
String scheme = req.getScheme();
int port = req.getServerPort();
if (port < 0) {
// Work around java.net.URL bug
port = 80;
}
if ("http".equals(scheme)) {
uri.append("ws");
} else if ("https".equals(scheme)) {
uri.append("wss");
} else {
// Should never happen
throw new IllegalArgumentException(
sm.getString("wsHandshakeRequest.unknownScheme", scheme));
}
uri.append("://");
uri.append(req.getServerName());
if ((scheme.equals("http") && (port != 80))
|| (scheme.equals("https") && (port != 443))) {
uri.append(':');
uri.append(port);
}
uri.append(req.getRequestURI());
if (req.getQueryString() != null) {
uri.append("?");
uri.append(req.getQueryString());
}
try {
return new URI(uri.toString());
} catch (URISyntaxException e) {
// Should never happen
throw new IllegalArgumentException(
sm.getString("wsHandshakeRequest.invalidUri", uri.toString()), e);
}
}
}
三：WebSocket服务代码
package com.demo.config.websocket.server;
import com.demo.config.websocket.WebSocketConfig;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import javax.servlet.http.HttpSession;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
@Slf4j
@Component
@ServerEndpoint(value = "/client/webSocket/scrollMessage", configurator = WebSocketConfig.class)
public class ScrollMessageWebSocketServer {
/**
* 客户端连接数量
*/
private AtomicInteger onlineCount = new AtomicInteger(0);
/**
* 存放客户端对应的Session对象
*/
private static ConcurrentHashMap<String, Session> webSocketServerPool = new ConcurrentHashMap<>();
/**
* 连接成功
*/
@OnOpen
public void onOpen(final Session session) {
log.debug("wsSession中的userProperties = [{}]", session.getUserProperties());
String userId = getHttpSessionUserId(session);
final int users = onlineCount.incrementAndGet();
webSocketServerPool.put(userId, session);
log.info("用户userId=[{}]连接成功，当前在线人数=[{}]", userId, users);
}
/**
* 连接关闭
*/
@OnClose
public void onClose(final Session session) {
String userId = getHttpSessionUserId(session);
webSocketServerPool.remove(userId);
final int users = onlineCount.decrementAndGet();
// final int users = onlineCount.get();
log.info("用户userId=[{}]退出！当前在线人数为=[{}]", userId, users);
}
/**
* 收到消息
*/
@OnMessage
public void onMessage(final String message, final Session session) {
String userId = getHttpSessionUserId(session);
log.debug("收到用户userId=[{}]的消息=[{}]", userId, message);
// webSocketServerPool.forEach((a, b) -> send2User(message, a));
}
/**
* 错误信息
*
* @param session
* @param error
*/
@OnError
public void onError(final Session session, final Throwable error) {
log.error("发生错误", error);
}
/**
* 发送消息
*
* @param message
* @throws IOException
*/
private static void sendMessage(final Session session, final String message) {
if (StringUtils.isBlank(message)) {
return;
}
try {
session.getBasicRemote().sendText(message);
} catch (IOException e) {
log.error("发送失败", e);
}
}
/**
* 发送信息给指定ID用户
*
* @param message 消息
* @param userId 用户ID
*/
public static void send2User(final String message, final String userId) {
if (StringUtils.isBlank(userId) || StringUtils.isBlank(message)) {
log.error("发送失败，消息message=[{}]为空或用户userId=[{}]为空", message, userId);
return;
}
Session session;
if (Objects.nonNull(session = webSocketServerPool.get(userId))) {
sendMessage(session, message);
log.debug("用户userId=[{}]发送发送成功", userId);
return;
}
log.debug("用户userId=[{}]发送失败,不存在或已下线", userId);
}
/**
* 发送信息给指定用户
*
* @param message 消息
* @param userIdList 用户列表
*/
public static void send2User(final String message, final List<String> userIdList) {
if (StringUtils.isBlank(message) || CollectionUtils.isEmpty(userIdList)) {
return;
}
userIdList.forEach((userId) -> send2User(message, userId));
}
/**
* 发送信息给所有用户
*
* @param message 消息
*/
public static void send2User(final String message) {
if (StringUtils.isBlank(message)) {
return;
}
webSocketServerPool.forEach((userId, session) -> sendMessage(session, message));
}
private String getHttpSessionUserId(Session session){
HttpSession httpSession = (HttpSession) session.getUserProperties().get("httpSession");
if (Objects.isNull(httpSession)){
log.error("httpSession为空, 请登录");
try {
session.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return httpSession.getAttribute("sessionUserId").toString();
}
}最后解释下为什么我直接从WebSocket的session中getUserProperties()，本来在配置中是将属性加在EndpointConfig的实现类ServerEndpointConfig中的，所有我们看看Session的源码，可以看到在构造session时将endpointConfig中的userProperties全部加入了session中
public class WsSession implements Session {
public WsSession(Endpoint localEndpoint,
WsRemoteEndpointImplBase wsRemoteEndpoint,
WsWebSocketContainer wsWebSocketContainer,
URI requestUri, Map<String, List<String>> requestParameterMap,
String queryString, Principal userPrincipal, String httpSessionId,
List<Extension> negotiatedExtensions, String subProtocol, Map<String, String> pathParameters,
boolean secure, EndpointConfig endpointConfig) throws DeploymentException {
this.localEndpoint = localEndpoint;
this.wsRemoteEndpoint = wsRemoteEndpoint;
this.wsRemoteEndpoint.setSession(this);
this.remoteEndpointAsync = new WsRemoteEndpointAsync(wsRemoteEndpoint);
this.remoteEndpointBasic = new WsRemoteEndpointBasic(wsRemoteEndpoint);
this.webSocketContainer = wsWebSocketContainer;
applicationClassLoader = Thread.currentThread().getContextClassLoader();
wsRemoteEndpoint.setSendTimeout(wsWebSocketContainer.getDefaultAsyncSendTimeout());
this.maxBinaryMessageBufferSize = webSocketContainer.getDefaultMaxBinaryMessageBufferSize();
this.maxTextMessageBufferSize = webSocketContainer.getDefaultMaxTextMessageBufferSize();
this.maxIdleTimeout = webSocketContainer.getDefaultMaxSessionIdleTimeout();
this.requestUri = requestUri;
if (requestParameterMap == null) {
this.requestParameterMap = Collections.emptyMap();
} else {
this.requestParameterMap = requestParameterMap;
}
this.queryString = queryString;
this.userPrincipal = userPrincipal;
this.httpSessionId = httpSessionId;
this.negotiatedExtensions = negotiatedExtensions;
if (subProtocol == null) {
this.subProtocol = "";
} else {
this.subProtocol = subProtocol;
}
this.pathParameters = pathParameters;
this.secure = secure;
this.wsRemoteEndpoint.setEncoders(endpointConfig);
this.endpointConfig = endpointConfig;
//在构造session时将endpointConfig中的userProperties全部加入了session中
this.userProperties.putAll(endpointConfig.getUserProperties());
this.id = Long.toHexString(ids.getAndIncrement());
InstanceManager instanceManager = webSocketContainer.getInstanceManager();
if (instanceManager == null) {
instanceManager = InstanceManagerBindings.get(applicationClassLoader);
}
if (instanceManager != null) {
try {
instanceManager.newInstance(localEndpoint);
} catch (Exception e) {
throw new DeploymentException(sm.getString("wsSession.instanceNew"), e);
}
}
if (log.isDebugEnabled()) {
log.debug(sm.getString("wsSession.created", id));
}
}
}