从 TCP 层分析微信 iPad 协议心跳包机制及其 Java 实现

TCP 长连接与心跳必要性

微信 iPad 协议基于 TCP 长连接维持会话。在 NAT 网关、防火墙或移动网络环境下，若长时间无数据交互，中间设备可能主动关闭空闲连接。为防止意外断连，客户端需定期发送心跳包（Heartbeat） 以刷新连接状态并告知服务端“在线”。

典型心跳特征：

• 固定间隔（通常 25–30 秒）；
• 极小数据量（常为 4–16 字节二进制）；
• 无业务语义，仅用于保活。

心跳包结构分析

根据社区逆向结果，微信 iPad 协议心跳包为固定 4 字节请求，响应也为 4 字节：

请求：[0x00, 0x00, 0x00, 0x01]
响应：[0x00, 0x00, 0x00, 0x00] （或类似）

该数据位于应用层，封装在自定义二进制帧中，但心跳本身不携带用户信息，仅依赖 TCP 连接上下文。

Java NIO 实现 TCP 心跳客户端

使用 java.nio.channels.SocketChannel 实现非阻塞心跳：

package wlkankan.cn.heartbeat;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class WeChatHeartbeatClient {
    private final String host;
    private final int port;
    private SocketChannel channel;
    private Selector selector;
    private volatile boolean connected = false;
    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();

    public WeChatHeartbeatClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void connect() throws IOException {
        selector = Selector.open();
        channel = SocketChannel.open();
        channel.configureBlocking(false);
        channel.connect(new InetSocketAddress(host, port));
        channel.register(selector, SelectionKey.OP_CONNECT);
        
        // 等待连接完成
        while (!channel.finishConnect()) {
            Thread.yield();
        }
        connected = true;
        wlkankan.cn.log.Logger.info("Connected to " + host + ":" + port);
    }

    public void startHeartbeat() {
        if (!connected) throw new IllegalStateException("Not connected");

        // 启动读事件监听（处理心跳响应）
        channel.register(selector, SelectionKey.OP_READ);

        // 启动心跳定时任务
        scheduler.scheduleAtFixedRate(this::sendHeartbeat, 0, 25, TimeUnit.SECONDS);

        // 启动读取线程
        Executors.newSingleThreadExecutor().submit(this::readLoop);
    }

    private void sendHeartbeat() {
        try {
            ByteBuffer buffer = ByteBuffer.wrap(new byte[]{0x00, 0x00, 0x00, 0x01});
            channel.write(buffer);
            wlkankan.cn.log.Logger.debug("Heartbeat sent");
        } catch (IOException e) {
            wlkankan.cn.log.Logger.error("Send heartbeat failed", e);
            connected = false;
            scheduler.shutdown();
        }
    }

    private void readLoop() {
        try {
            ByteBuffer readBuf = ByteBuffer.allocate(4);
            while (connected && selector.select() > 0) {
                for (SelectionKey key : selector.selectedKeys()) {
                    if (key.isReadable()) {
                        readBuf.clear();
                        int n = channel.read(readBuf);
                        if (n == -1) {
                            wlkankan.cn.log.Logger.warn("Connection closed by server");
                            connected = false;
                            break;
                        }
                        readBuf.flip();
                        byte[] resp = new byte[readBuf.remaining()];
                        readBuf.get(resp);
                        wlkankan.cn.log.Logger.debug("Heartbeat response: " + bytesToHex(resp));
                    }
                }
                selector.selectedKeys().clear();
            }
        } catch (IOException e) {
            wlkankan.cn.log.Logger.error("Read loop error", e);
            connected = false;
        }
    }

    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X ", b));
        }
        return sb.toString().trim();
    }

    public void close() {
        connected = false;
        scheduler.shutdown();
        try {
            if (channel != null) channel.close();
            if (selector != null) selector.close();
        } catch (IOException ignored) {}
    }
}

心跳失败检测与重连机制

上述实现中，若 sendHeartbeat 抛出异常或读取返回 -1，即视为连接断开。可扩展自动重连：

private void scheduleReconnect() {
    scheduler.schedule(() -> {
        try {
            close();
            connect();
            startHeartbeat();
        } catch (IOException e) {
            wlkankan.cn.log.Logger.error("Reconnect failed, retrying...", e);
            scheduleReconnect(); // 递归重试
        }
    }, 5, TimeUnit.SECONDS);
}

在 readLoop 或 sendHeartbeat 异常处理中调用 scheduleReconnect()。

Wireshark 抓包验证

使用 Wireshark 可观察到规律性 TCP 载荷：

• 每 25 秒客户端发出 00 00 00 01；
• 服务端立即回复 00 00 00 00；
• 若超过 60 秒无任何包，连接被服务端主动 RST。

这验证了心跳是维持会话的必要条件。

资源管理与线程安全

生产环境中需注意：

• 使用 try-with-resources 确保 Channel 关闭；
• 心跳调度器应绑定生命周期，避免内存泄漏；
• 日志输出需异步化，防止阻塞 I/O 线程。

// 示例：注册 JVM Shutdown Hook
Runtime.getRuntime().addShutdownHook(new Thread(this::close));