springboot WebSocket的使用
1、前言
在springboot中开发websock相关功能，报Error during WebSocket handshake Unexpected response code 404
2、原因分析
发现是websocket绑定终结点错误，需要添加WebSocketConfig
package com.ruoyi.framework.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;
@Configuration
public class WebSocketConfig {
/**
* 注入一个ServerEndpointExporter,该Bean会自动注册使用@ServerEndpoint注解申明的websocket endpoint
*/
@Bean
public ServerEndpointExporter serverEndpointExporter() {
return new ServerEndpointExporter();
}
}
还需ShiroConfig权限通过
filterChainDefinitionMap.put("/ws/**", "anon");
3、补充websock和smartSocket结合使用
package com.ruoyi.project.front.socket;
import org.smartboot.socket.MessageProcessor;
import org.smartboot.socket.StateMachineEnum;
import org.smartboot.socket.transport.AioQuickServer;
import org.smartboot.socket.transport.AioSession;
import org.springframework.stereotype.Component;
import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.concurrent.ExecutionException;
@Component
@ServerEndpoint("/ws/webSocket")
public class AudioWebSocket implements MessageProcessor<String> {
//███████████████ websocket ████████████████████████████████████████████████████████████████████████████████████
//静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
/**
* 在线数量
*/
private static int onlineCount = 0;
/**
* 获取在线数量
*/
public static synchronized int getOnlineCount() {
return onlineCount;
}
/**
* 增加在线数量
*/
public static synchronized void addOnlineCount() {
AudioWebSocket.onlineCount++;
}
/**
* 减去在线数量
*/
public static synchronized void subOnlineCount() {
AudioWebSocket.onlineCount--;
}
/**
* websocket集合
*/
//concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。若要实现服务端与单一客户端通信的话，可以使用Map来存放，其中Key可以为用户标识
private static CopyOnWriteArraySet<AudioWebSocket> webSocketSet = new CopyOnWriteArraySet<>();
/**
* webSocketSession
*/
//与某个客户端的连接会话，需要通过它来给客户端发送数据 websocket
private Session webSocketSession;
@OnOpen
public void onOpen(Session session) throws IOException, ExecutionException, InterruptedException {
System.out.println("websocket connect");
this.webSocketSession = session;
webSocketSet.add(this); //加入set中
addOnlineCount(); //在线数加1
}
@OnClose
public void onClose() {
webSocketSet.remove(this); //从set中删除
subOnlineCount(); //在线数减1
}
@OnError
public void onError(Session session, Throwable error) {
error.printStackTrace();
}
@OnMessage
public void onMessage(String message, Session session) {
System.out.println("来自客户端的消息:" + message);
// if (message.startsWith("CC")) {
// Timer timer = new Timer();
// timer.schedule(new TimerTask() {
// @Override
// public void run() {
// sendMessageToAllClient(SimpleDateFormat.getDateInstance().format(new Date()) + "222");
// }
// }, 0, 1000);
// }
}
public synchronized void sendMessageToAllClient(String message) {
for (AudioWebSocket item : webSocketSet) {
try {
item.webSocketSession.getBasicRemote().sendText(message);
} catch (IOException e) {
e.printStackTrace();
continue;
}
}
}
//███████████████ AioSession ████████████████████████████████████████████████████████████████████████████████████
public static void aioStart() {
try {
aioQuickServer = new AioQuickServer<>(12000, new SinglechipFormProtocol(), new AudioWebSocket());
aioQuickServer.setReadBufferSize(2048);
aioQuickServer.start();
System.out.println("通信模块 服务启动 ");
} catch (Exception e) {
e.printStackTrace();
// LogHelper.info("通信模块 socket服务关闭 ");
aioQuickServer.shutdown();
}
}
public static void defend() {
new Thread(() -> {
aioStart();
}).start();
}
/**
* 服务端变量
*/
public static AioQuickServer<String> aioQuickServer;
//与某个客户端的连接会话，需要通过它来给客户端发送数据
/**
* aioSession
*/
private static AioSession<String> aioSession;
@Override
public void process(AioSession<String> aioSession, String s) {
System.out.println("aioSession " + s);
sendMessageToAllClient(s);
}
@Override
public void stateEvent(AioSession<String> aioSession, StateMachineEnum stateMachineEnum, Throwable throwable) {
switch (stateMachineEnum) {
case NEW_SESSION:
this.aioSession = aioSession;
System.out.println("通信模块 NEW_SESSION state:" + stateMachineEnum);
break;
case SESSION_CLOSED:
System.out.println("通信模块 SESSION_CLOSED state:" + stateMachineEnum);
this.aioSession = null;
break;
default:
System.out.println("通信模块 other state:" + stateMachineEnum + " " + throwable.toString());
break;
}
}
}
SinglechipFormProtocol
package com.ruoyi.project.front.socket;
import org.smartboot.socket.Protocol;
import org.smartboot.socket.transport.AioSession;
import java.nio.ByteBuffer;
public class SinglechipFormProtocol implements Protocol<String> {
private static final int INT_LENGTH = 4;
@Override
public String decode(ByteBuffer readBuffer, AioSession<String> session, boolean bool) {
// TODO Auto-generated method stub
int length = readBuffer.limit();
if (readBuffer.remaining() < INT_LENGTH) {
return null;
}
byte[] bytes = new byte[length];
readBuffer.get(bytes, 0, length);
String retStr = new String(bytes);
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
// retStr = sdf.format(new Date())+ ","+ retStr;
return retStr;
}
@Override
public ByteBuffer encode(String str, AioSession<String> session) {
// TODO Auto-generated method stub
byte[] dd = str.getBytes();
ByteBuffer b = ByteBuffer.allocate(INT_LENGTH);
b.put(dd);
b.flip();
return b;
}
}
pom.xml
<dependency>
<groupId>org.smartboot.socket</groupId>
<artifactId>aio-core</artifactId>
<version>1.3.12</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
浙公网安备 33010602011771号