使用Undertow实现WebSocket前后端消息推送

要使用Undertow实现WebSocket前后端消息推送，可以按照以下步骤进行：

1. 在后端实现WebSocket处理器，代码如下：

import io.undertow.server.HttpServerExchange;
import io.undertow.websockets.core.*;
import io.undertow.websockets.spi.WebSocketHttpExchange;
import io.undertow.websockets.spi.WebSocketSession;

public class WebSocketHandler implements WebSocketConnectionCallback {
    @Override
    public void onConnect(WebSocketHttpExchange exchange, WebSocketChannel channel) {
        // WebSocket连接建立时触发
        System.out.println("WebSocket连接建立");
        // 创建WebSocket会话
        WebSocketSession session = new UndertowWebSocketSession(channel);
        // 将WebSocket会话保存到会话管理器中
        WebSocketSessionManager.addSession(session);
        // 注册WebSocket消息处理器
        channel.getReceiveSetter().set(new WebSocketMessageHandler(session));
        channel.resumeReceives();
    }
}

class WebSocketMessageHandler implements WebSocketCallback<WebSocketChannel> {
    private WebSocketSession session;

    public WebSocketMessageHandler(WebSocketSession session) {
        this.session = session;
    }

    @Override
    public void onError(WebSocketChannel channel, Throwable throwable) {
        // WebSocket出错时触发
        System.out.println("WebSocket出错");
        throwable.printStackTrace();
    }

    @Override
    public void onClose(WebSocketChannel channel, StreamSourceFrameChannel channel1) throws IOException {
        // WebSocket连接关闭时触发
        System.out.println("WebSocket连接关闭");
        // 从会话管理器中删除WebSocket会话
        WebSocketSessionManager.removeSession(session);
    }

    @Override
    public void onFullTextMessage(WebSocketChannel channel, BufferedTextMessage message) {
        // 收到完整的文本消息时触发
        System.out.println("收到文本消息：" + message.getData());
        // 处理WebSocket消息
        // ...
    }
}

2. 在Undertow服务器中添加WebSocket处理器，代码如下：

import io.undertow.Handlers;
import io.undertow.Undertow;
import io.undertow.server.RoutingHandler;
import io.undertow.server.handlers.PathHandler;
import io.undertow.server.handlers.resource.ClassPathResourceManager;
import io.undertow.server.handlers.resource.ResourceHandler;
import io.undertow.server.handlers.resource.ResourceManager;
import io.undertow.server.handlers.websocket.WebSocketProtocolHandshakeHandler;

public class WebSocketServer {
    public static void main(String[] args) {
        // 创建Web资源管理器
        ResourceManager resourceManager = new ClassPathResourceManager(WebSocketServer.class.getClassLoader(), "web");
        // 创建Web资源处理器
        ResourceHandler resourceHandler = new ResourceHandler(resourceManager);
        // 创建WebSocket处理器
        WebSocketConnectionCallback callback = new WebSocketHandler();
        WebSocketProtocolHandshakeHandler websocketHandler = new WebSocketProtocolHandshakeHandler(callback);
        // 创建路由处理器
        RoutingHandler routingHandler = Handlers.routing()
                .get("/", resourceHandler)
                .get("/{path}", resourceHandler)
                .get("/websocket", websocketHandler);
        // 创建路径处理器
        PathHandler pathHandler = Handlers.path(routingHandler)
                .addPrefixPath("/", resourceHandler);
        // 创建Undertow服务器
        Undertow server = Undertow.builder()
                .addHttpListener(8080, "localhost")
                .setHandler(pathHandler)
                .build();
        // 启动Undertow服务器
        server.start();
    }
}

3. 在前端使用WebSocket连接到后端，代码如下：

var websocket = new WebSocket("ws://localhost:8080/websocket");
websocket.onopen = function() {
    console.log("WebSocket连接建立");
};
websocket.onclose = function() {
    console.log("WebSocket连接关闭");
};
websocket.onerror = function() {
    console.log("WebSocket出错");
};
websocket.onmessage = function(event) {
    console.log("收到文本消息：" + event.data);
};

4. 在后端向前端发送消息，代码如下：

import io.undertow.websockets.core.*;
import io.undertow.websockets.spi.WebSocketSession;

public class WebSocketSessionManager {
    private static Set<WebSocketSession> sessions = new HashSet<>();

    public static void addSession(WebSocketSession session) {
        sessions.add(session);
    }

    public static void removeSession(WebSocketSession session) {
        sessions.remove(session);
    }

    public static void sendMessage(String message) {
        for (WebSocketSession session : sessions) {
            try {
                session.send(new StringWebSocketMessage(message));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

调用`WebSocketSessionManager.sendMessage()`方法即可向所有前端客户端发送消息。