Java WebSocket实时通信教程与应用技巧

Java WebSocket程序基于JSR 356规范，使用@ServerEndpoint和@ClientEndpoint注解分别实现服务端和客户端；2. 服务端通过@OnOpen、@OnMessage、@OnClose、@OnError处理连接生命周期事件，Session用于消息收发；3. 客户端通过WebSocketContainer连接服务端，使用CountDownLatch同步控制；4. 高并发处理可通过线程池、NIO或消息队列实现；5. 安全性通过WSS协议、SSL证书和身份验证保障；6. 心跳检测通过定时发送PING/PONG消息实现，服务端使用ScheduledExecutorService周期发送PING，客户端需回复PONG以维持连接；7. 程序需部署在支持WebSocket的服务器如Tomcat 8+，客户端使用wss://协议确保通信安全，完整实现了实时双向通信机制。

WebSocket实时通信程序，说白了，就是让你的Java程序能像聊天室一样，服务器和客户端可以随时互发消息，不用像传统的HTTP请求那样，客户端得先问一句，服务器才能回一句。这玩意儿在需要实时更新数据的场景里特别有用，比如股票行情、在线游戏啥的。

解决方案

要用Java写WebSocket程序，主要靠的就是JSR 356规范，也就是Java WebSocket API。你可以把它理解成Java官方提供的WebSocket工具包。

1. 引入依赖： 先在你的Maven或者Gradle项目里加上WebSocket API的依赖。比如Maven的pom.xml文件里：

    jakarta.websocket
    jakarta.websocket-api
    2.1.0 
    provided 

2. 编写服务端：

   • 创建一个类，用@ServerEndpoint注解标记它，这个注解告诉服务器，这个类是一个WebSocket端点。@ServerEndpoint里可以指定一个URI，客户端通过这个URI连接到服务器。

   import jakarta.websocket.*;
   import jakarta.websocket.server.ServerEndpoint;
   import java.io.IOException;
   
   @ServerEndpoint("/websocket")
   public class MyWebSocketServer {
   
       @OnOpen
       public void onOpen(Session session) {
           System.out.println("Client connected: " + session.getId());
       }
   
       @OnMessage
       public void onMessage(String message, Session session) throws IOException {
           System.out.println("Received message: " + message + " from " + session.getId());
           // 将消息广播给所有连接的客户端，或者只发给特定的客户端
           session.getBasicRemote().sendText("Server received: " + message); // Echo back
       }
   
       @OnClose
       public void onClose(Session session) {
           System.out.println("Client disconnected: " + session.getId());
       }
   
       @OnError
       public void onError(Throwable error) {
           error.printStackTrace();
       }
   }

   • @OnOpen、@OnMessage、@OnClose、@OnError 这几个注解分别对应WebSocket的几个事件：连接建立、收到消息、连接关闭、发生错误。

   • Session对象代表一个客户端连接。你可以用它来发送消息，获取客户端信息等等。

3. 编写客户端：

   • 同样，创建一个类，用@ClientEndpoint注解标记。

   import jakarta.websocket.*;
   import java.net.URI;
   import java.net.URISyntaxException;
   import java.io.IOException;
   import java.util.concurrent.CountDownLatch;
   
   @ClientEndpoint
   public class MyWebSocketClient {
   
       private CountDownLatch latch = new CountDownLatch(1);
   
       @OnOpen
       public void onOpen(Session session) {
           System.out.println("Connected to server: " + session.getId());
           try {
               session.getBasicRemote().sendText("Hello Server!");
           } catch (IOException e) {
               e.printStackTrace();
           }
       }
   
       @OnMessage
       public void onMessage(String message, Session session) {
           System.out.println("Received message: " + message + " from server");
           latch.countDown(); // 收到消息后，解锁
       }
   
       @OnClose
       public void onClose(Session session) {
           System.out.println("Disconnected from server: " + session.getId());
       }
   
       @OnError
       public void onError(Throwable error) {
           error.printStackTrace();
       }
   
       public CountDownLatch getLatch() {
           return latch;
       }
   
       public static void main(String[] args) throws URISyntaxException, DeploymentException, IOException, InterruptedException {
           WebSocketContainer container = ContainerProvider.getWebSocketContainer();
           Session session = container.connectToServer(MyWebSocketClient.class, new URI("ws://localhost:8080/websocket")); // 替换为你的服务器地址
           MyWebSocketClient client = (MyWebSocketClient) session.getUserProperties().get(MyWebSocketClient.class.getName());
           client.getLatch().await(); // 等待收到消息
           session.close();
       }
   }

   • 客户端需要一个WebSocket容器来建立连接。ContainerProvider.getWebSocketContainer()可以获取默认的容器。

   • container.connectToServer()方法用来连接到服务器。

4. 部署和运行：

   • 把你的服务端代码部署到支持WebSocket的Java Web服务器上，比如Tomcat。注意，Tomcat的版本要足够高，比如Tomcat 8.0以上。

   • 运行你的客户端代码。

Java WebSocket如何处理高并发？

WebSocket本身是基于TCP的，所以高并发的处理方式和普通的网络编程类似。主要思路就是使用多线程或者异步IO。

• 线程池： 每个WebSocket连接都分配一个线程来处理消息。可以用线程池来管理这些线程，避免创建过多的线程导致系统崩溃。

• 异步IO (NIO)： Java NIO提供了非阻塞的IO操作。可以用它来处理WebSocket连接，一个线程可以处理多个连接，提高并发能力。Netty框架就 heavily 使用了 NIO。

• 消息队列： 如果消息处理逻辑比较复杂，可以将消息放入消息队列，然后用多个消费者线程来处理消息。这样可以避免单个线程阻塞，提高系统的吞吐量。比如使用 Kafka 或者 RabbitMQ。

如何保证WebSocket通信的安全性？

WebSocket默认是不加密的，所以需要使用WSS协议来保证通信的安全性。WSS就是WebSocket over SSL/TLS，相当于HTTPS之于HTTP。

• 配置SSL证书： 在你的Web服务器上配置SSL证书。具体的配置方法取决于你使用的Web服务器。

• 使用WSS协议： 客户端连接服务器的时候，使用wss://协议代替ws://协议。

• 身份验证： 可以使用HTTP认证或者自定义的认证方式来验证客户端的身份。可以在@OnOpen方法里进行身份验证。

WebSocket心跳检测机制如何实现？

心跳检测是为了检测客户端和服务器之间的连接是否仍然有效。如果长时间没有收到对方的消息，就认为连接已经断开。

• 定时发送心跳包： 客户端和服务器定时向对方发送心跳包。心跳包就是一个特殊的消息，比如PING或者PONG。

• 超时判断： 如果在一段时间内没有收到对方的心跳包，就认为连接已经断开，关闭连接。

服务器端实现心跳检测的一个简单例子：

import jakarta.websocket.*;
import jakarta.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@ServerEndpoint("/heartbeat")
public class HeartbeatWebSocketServer {

    private Session session;
    private ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
    private static final long HEARTBEAT_INTERVAL = 30; // seconds

    @OnOpen
    public void onOpen(Session session) {
        this.session = session;
        System.out.println("Client connected: " + session.getId());

        // Start sending heartbeat messages
        scheduler.scheduleAtFixedRate(this::sendHeartbeat, HEARTBEAT_INTERVAL, HEARTBEAT_INTERVAL, TimeUnit.SECONDS);
    }

    private void sendHeartbeat() {
        try {
            if (session != null && session.isOpen()) {
                session.getBasicRemote().sendText("PING");
            } else {
                System.out.println("Session closed, stopping heartbeat.");
                scheduler.shutdown();
            }
        } catch (IOException e) {
            System.err.println("Error sending heartbeat: " + e.getMessage());
            scheduler.shutdown();
        }
    }

    @OnMessage
    public void onMessage(String message, Session session) throws IOException {
        System.out.println("Received message: " + message + " from " + session.getId());
        if ("PONG".equals(message)) {
            System.out.println("Received PONG from client, connection is alive.");
        } else {
            session.getBasicRemote().sendText("Server received: " + message);
        }
    }

    @OnClose
    public void onClose(Session session) {
        System.out.println("Client disconnected: " + session.getId());
        scheduler.shutdown();
    }

    @OnError
    public void onError(Throwable error) {
        error.printStackTrace();
        scheduler.shutdown();
    }
}

客户端也需要类似的机制，收到PING后回复PONG，或者在一定时间内没有收到PING就认为连接断开。这部分代码就留给你自己去实现了。