【Java长连接开发完全技术手册（从Socket底层、IO模型、TCP机制到Netty生产落地）】

标签：#Java长连接 #TCP #Netty #IO多路复用 #物联网开发 #服务端开发

摘要：本文从工程开发角度，系统化整理 Java 长连接开发全套必备技术能力。摒弃面试科普内容，聚焦底层原理、开发难点、TCP机制、IO模型差异、粘包拆包、心跳保活、会话管理、并发优化、生产避坑，是长连接服务端开发的完整技术栈手册。

一、长连接核心本质（开发必须吃透）

TCP 协议本身是面向连接、面向字节流、可靠、有序的长连接协议。

短连接是业务层行为（通信完主动关闭），长连接是协议层特性+业务层维护。

长连接服务开发核心本质只有三件事：

1. 维持链路存活：解决断开、静默掉线、网络震荡

2. 界定报文边界：解决TCP流式无边界导致的粘包拆包

3. 管理连接状态：设备在线、离线、会话绑定、双向通信

所有长连接框架、业务逻辑、优化方案，全部围绕这三点展开。

二、Java 三种 IO 模型工程差异（为什么只用 Netty）

2.1 BIO 同步阻塞（彻底不具备长连接能力）

BIO 模型为 一连接一线程，线程阻塞在 read 方法。

工程缺陷：

• 连接数 = 线程数，无法支撑海量连接

• 空闲连接持续占用线程资源

• 无法做超时、心跳、异步处理

结论：BIO 不具备生产长连接开发价值。

2.2 JDK NIO 原生多路复用（能力够用、工程难用）

NIO 核心能力：单线程可管理成千上万个连接。

核心组件：Selector、Channel、ByteBuffer。

原生 NIO 工程硬伤（导致没人用）：

• 需要手动处理 空轮询 CPU100% BUG

• 需要手动处理半包、粘包、缓冲区复位

• 无线程模型封装、无连接生命周期管理

• 无空闲检测、无异常隔离、无内存回收机制

2.3 Netty（工业级长连接标准实现）

Netty 不是新 IO 模型，是 JDK NIO 的工业级封装与修复。

Netty 解决了原生 NIO 所有工程问题，同时提供长连接开发全套能力：

• 修复空轮询 Bug

• Reactor 线程模型解耦连接/读写/业务

• Pipeline 责任链模式，分层处理协议

• 内置缓冲区内存池、零拷贝

• 内置空闲检测、拆包器、异常机制

工程结论：Java 所有生产长连接服务，统一使用 Netty。

三、TCP 长连接三大核心技术难题（开发核心技能）

3.1 字节流无边界：粘包拆包问题（最核心）

TCP 只保证字节流可靠传输，不认识业务数据包。

发包两次、收包一次 = 粘包

发包一次、收包多次 = 拆包

所有自定义 TCP 协议必须手动解决边界问题，四种工业方案：

1. 定长报文：固定长度读写，简单但浪费流量

2. 分隔符报文：首尾特殊标记（如808协议 0x7E）

3. 长度域报文（主流）：消息头携带消息体长度，先读长度再读数据

4. 结构化协议：Protobuf、JSON 流式解析

长连接协议开发，必须掌握自定义拆包器开发能力。

3.2 链路静默失效：心跳与空闲检测

TCP 系统层 KeepAlive 只能检测链路断连，无法检测设备死机、应用卡死、内网断流。

生产必须自研应用层心跳机制：

• 客户端定时推送心跳包

• 服务端基于 Netty IdleStateHandler 做读空闲检测

• 超时主动关闭通道、清理会话

核心能力：实现应用层心跳兜底、精准离线判定、无效链路主动回收，规避系统层心跳的滞后性与局限性。

下面附上全套可直接运行的生产级Netty长连接Demo，包含：服务端启动、自定义长度域拆包器、心跳空闲检测、全局会话管理、业务处理器，逐行代码解析，完全适配自定义TCP长连接协议开发。

四、Netty长连接完整落地Demo（可直接上线）

本次Demo采用工业最主流的【消息头+长度域】协议规范，完美解决粘包拆包，集成心跳保活、会话管理、异常隔离，是企业IoT、车载、TCP长连接项目通用模板。

4.1 核心Maven依赖

<!-- 稳定生产版Netty依赖 -->
<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.100.Final</version>
</dependency>

4.2 服务端启动核心类（主从Reactor线程模型）

采用生产标准主从线程模型，解耦连接接收与业务处理，支持海量长连接常驻。

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * Netty长连接服务端启动类（生产标准）
 */
public class NettyTcpServer {
    // Boss线程：仅处理客户端连接接入，单线程足够
    private static final EventLoopGroup BOSS_GROUP = new NioEventLoopGroup(1);
    // Worker线程：处理读写、解码、业务逻辑，默认CPU核心数*2
    private static final EventLoopGroup WORKER_GROUP = new NioEventLoopGroup();

    public void start(int port) {
        ServerBootstrap bootstrap = new ServerBootstrap();
        bootstrap.group(BOSS_GROUP, WORKER_GROUP)
                // 指定NIO服务端通道
                .channel(NioServerSocketChannel.class)
                // 开启系统TCP保活，辅助兜底
                .option(ChannelOption.SO_KEEPALIVE, true)
                // 连接队列最大缓冲数
                .option(ChannelOption.SO_BACKLOG, 1024)
                // 关闭Nagle算法，实时传输报文，降低长连接延迟
                .childOption(ChannelOption.TCP_NODELAY, true)
                // 初始化通道处理器链
                .childHandler(new ServerChannelInitializer());

        try {
            // 同步绑定端口，启动服务
            ChannelFuture future = bootstrap.bind(port).sync();
            System.out.println("✅ Netty长连接服务启动成功，监听端口：" + port);
            // 阻塞监听服务关闭事件
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("❌ 长连接服务启动失败");
        } finally {
            // 优雅停机，释放线程资源
            BOSS_GROUP.shutdownGracefully();
            WORKER_GROUP.shutdownGracefully();
        }
    }

    public static void main(String[] args) {
        // 启动服务，自定义端口
        new NettyTcpServer().start(8888);
    }
}

4.3 通道初始化器（处理器链组装）

统一装配空闲心跳检测、自定义拆包器、业务处理器，遵循Netty责任链设计，分层处理协议逻辑。

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.timeout.IdleStateHandler;
import java.util.concurrent.TimeUnit;

/**
 * 通道初始化器：组装长连接核心处理器
 */
public class ServerChannelInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) {
        ChannelPipeline pipeline = ch.pipeline();

        // 空闲心跳检测：60秒未读报文=设备静默掉线，触发空闲事件
        pipeline.addLast(new IdleStateHandler(60, 0, 0, TimeUnit.SECONDS));
        // 核心：自定义长度域拆包器（解决粘包拆包）
        pipeline.addLast(new LengthFieldMsgDecoder());
        // 自定义业务处理器（报文解析、会话管理、业务逻辑）
        pipeline.addLast(new TcpBusinessHandler());
    }
}

4.4 自定义长度域拆包器（彻底解决粘包拆包）

基于Netty自带长度域解码器改造，适配自定义TCP协议，是长连接协议开发最通用的方案，支持任意变长报文解析。

协议规则：消息头4字节（存储消息体长度） + 消息体（变长业务数据）

import io.netty.handler.codec.LengthFieldBasedFrameDecoder;

/**
 * 自定义长度域拆包器
 * 解决TCP粘包、拆包、半包问题，生产通用方案
 */
public class LengthFieldMsgDecoder extends LengthFieldBasedFrameDecoder {
    /**
     * 构造参数逐行解释：
     * 1. 最大帧长度：1024*1024（单条报文最大1M，防止恶意超大报文攻击）
     * 2. 长度域偏移量：0（长度域在报文最开头）
     * 3. 长度域占用字节：4字节
     * 4. 长度调整值：0（长度域数值=消息体长度）
     * 5. 跳过初始字节数：0（不丢弃报文头）
     */
    public LengthFieldMsgDecoder() {
        super(1024 * 1024, 0, 4, 0, 0);
    }
}

4.5 全局会话管理器（长连接有状态核心）

长连接为有状态服务，通过线程安全的ConcurrentHashMap管理所有在线设备通道，实现精准下发、在线统计、断线清理。

import io.netty.channel.Channel;
import io.netty.channel.ChannelId;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 全局长连接会话管理器（生产增强版）
 * 能力：会话存储、精准下发、在线统计、僵尸连接清理、ChannelId唯一标识
 */
public class ChannelSessionManager {
    // 基于Netty原生ChannelId做唯一标识，杜绝IP端口重复问题
    private static final ConcurrentHashMap<ChannelId, Channel> ONLINE_SESSION = new ConcurrentHashMap<>();

    // 存入在线会话
    public static void putSession(Channel channel) {
        ONLINE_SESSION.put(channel.id(), channel);
    }

    // 移除离线会话
    public static void removeSession(Channel channel) {
        ONLINE_SESSION.remove(channel.id());
    }

    // 获取指定通道
    public static Channel getChannel(ChannelId channelId) {
        return ONLINE_SESSION.get(channelId);
    }

    // 获取在线连接总数
    public static int getOnlineCount() {
        return ONLINE_SESSION.size();
    }

    // 全局广播：向所有在线设备下发报文
    public static void broadcast(byte[] data) {
        ONLINE_SESSION.values().forEach(channel -> {
            if (channel.isActive() && channel.isOpen()) {
                channel.writeAndFlush(data);
            }
        });
    }

    // 精准单点下发报文
    public static void sendData(Channel channel, byte[] data) {
        if (channel != null && channel.isActive() && channel.isOpen()) {
            channel.writeAndFlush(data);
        }
    }

    // 主动清理所有失效僵尸连接
    public static void clearInvalidChannel() {
        ONLINE_SESSION.entrySet().removeIf(entry -> !entry.getValue().isActive());
    }
}

4.6 核心业务处理器（心跳、上下线、报文处理）

实现连接上下线回调、心跳超时断线、报文接收解析、异常隔离，是长连接业务逻辑的核心入口。

import io.netty.buffer.ByteBuf;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;
import io.netty.util.CharsetUtil;

/**
 * TCP长连接业务处理器（生产最终版）
 * 优化点：唯一会话存储、僵尸连接清理、心跳精准判定、无内存泄漏、异常强隔离
 */
public class TcpBusinessHandler extends ChannelInboundHandlerAdapter {

    // 设备上线：注册会话
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        Channel channel = ctx.channel();
        ChannelSessionManager.putSession(channel);
        System.out.println("🟢 设备上线｜通道ID：" + channel.id() + "｜当前在线总数：" + ChannelSessionManager.getOnlineCount());
    }

    // 设备离线：销毁会话
    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        Channel channel = ctx.channel();
        ChannelSessionManager.removeSession(channel);
        // 定时兜底清理无效连接
        ChannelSessionManager.clearInvalidChannel();
        System.out.println("🔴 设备离线｜通道ID：" + channel.id() + "｜当前在线总数：" + ChannelSessionManager.getOnlineCount());
    }

    // 读取设备上报报文
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf byteBuf = (ByteBuf) msg;
        try {
            String data = byteBuf.toString(CharsetUtil.UTF_8);
            System.out.println("📥 接收设备报文：" + data);
        } finally {
            // 强制释放内存，100%杜绝内存泄漏
            byteBuf.release();
        }
    }

    // 心跳超时：判定静默掉线，主动销毁链路
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            if (event.state() == IdleState.READER_IDLE) {
                System.out.println("⏰ 设备心跳超时，判定为僵尸连接，主动关闭通道");
                ctx.close();
            }
        }
    }

    // 异常隔离：单连接异常不影响全局服务
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        System.err.println("❌ 单设备连接异常，隔离失效通道");
        ctx.close();
    }
}

五、核心代码能力解析（开发重点）

5.1 拆包器核心原理

放弃低效的分隔符、定长报文方案，采用长度域动态解析，先读取4字节消息体长度，再精准读取对应长度的业务数据，从根源彻底杜绝粘包、拆包、半包问题，适配所有变长TCP协议。

5.2 心跳机制核心逻辑

摒弃系统层TCP KeepAlive，基于Netty IdleStateHandler实现应用层心跳，精准识别：设备死机、内网断流、网络震荡、进程卡死等隐性掉线场景，超时主动回收连接，避免僵尸连接堆积占用资源。

5.3 内存泄漏防控

Netty ByteBuf 为手动管理内存，必须在 finally 块执行 release()，否则会导致服务长期运行内存溢出、OOM崩溃，是长连接服务生产必守规范。

5.4 异常隔离机制

重写 exceptionCaught 方法，单个设备报文异常、解码失败、连接报错时，仅关闭当前失效通道，不影响其他正常在线设备，保证服务高可用。

六、Demo扩展生产能力

本Demo为基础模板，可直接扩展适配各类长连接业务：

• 适配JT/T808车载协议：替换自定义拆包器为0x7E分隔符拆包，新增808报文解码逻辑

• 实现断线重连：客户端新增连接断开回调+定时重试逻辑

• 实现批量优化：添加异步批量处理注解，高频报文批量入库

• 实现集群部署：整合Redis实现分布式会话共享、负载均衡

• 实现报文加密：新增AES加密解密处理器，保障传输安全

七、配套客户端：断线自动重连完整实现（可直接运行）

生产长连接客户端核心刚需：断网、服务重启、网络波动、链路断开后，自动延迟重试、无限重连、恢复心跳通信。

以下代码与上文服务端协议完全对齐、可无缝联调，具备能力：自动重连、重连避退、异常重试、正常通信、资源可控。

7.1 客户端通道初始化器

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.timeout.IdleStateHandler;
import java.util.concurrent.TimeUnit;

/**
 * 客户端通道初始化：与服务端处理器对齐
 */
public class ClientChannelInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) {
        ChannelPipeline pipeline = ch.pipeline();
        // 客户端心跳：50秒写空闲发送心跳包
        pipeline.addLast(new IdleStateHandler(0, 50, 0, TimeUnit.SECONDS));
        // 和服务端一致：长度域拆包器
        pipeline.addLast(new LengthFieldMsgDecoder());
        // 客户端业务处理器（含重连逻辑）
        pipeline.addLast(new TcpClientHandler());
    }
}

7.2 客户端核心处理器（含断线重连触发、心跳发送）

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleState;
import io.netty.handler.timeout.IdleStateEvent;

/**
 * 客户端处理器（生产优化版）
 * 1. 指数退避断线重连、无限自愈
 * 2. 定时上报心跳包维持链路
 * 3. 响应服务端下行指令
 * 4. 异常隔离、资源保护
 */
public class TcpClientHandler extends ChannelInboundHandlerAdapter {

    // 初始重连延迟、最大重连间隔、退避倍率
    private static final int BASE_RECONNECT_DELAY = 3;
    private static final int MAX_RECONNECT_DELAY = 30;
    private int currentDelay = BASE_RECONNECT_DELAY;

    // 通道断开：触发指数退避重连
    @Override
    public void channelInactive(ChannelHandlerContext ctx) {
        System.out.println("🔴 客户端链路断开，" + currentDelay + "秒后尝试重连");
        ctx.channel().eventLoop().schedule(() -> {
            NettyTcpClient.connect();
        }, currentDelay, java.util.concurrent.TimeUnit.SECONDS);
        // 指数递增，封顶保护
        currentDelay = Math.min(currentDelay * 2, MAX_RECONNECT_DELAY);
    }

    // 连接成功：重置重连间隔
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        System.out.println("🟢 客户端成功接入服务端，长连接链路建立完成");
        // 连接成功重置退避时间，恢复初始策略
        currentDelay = BASE_RECONNECT_DELAY;
    }

    // 写空闲触发：主动上报心跳包
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent) evt;
            if (event.state() == IdleState.WRITER_IDLE) {
                // 标准心跳报文：4字节长度域 + 心跳内容
                String heartData = "heart_beat";
                byte[] dataBytes = heartData.getBytes();
                ByteBuf buf = Unpooled.buffer();
                buf.writeInt(dataBytes.length);
                buf.writeBytes(dataBytes);
                ctx.writeAndFlush(buf);
                System.out.println("💓 客户端上报心跳包，维持长连接存活");
            }
        }
        super.userEventTriggered(ctx, evt);
    }

    // 接收服务端下行数据
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf byteBuf = (ByteBuf) msg;
        try {
            String data = byteBuf.toString(io.netty.util.CharsetUtil.UTF_8);
            System.out.println("📥 客户端接收服务端指令：" + data);
            // 可扩展：指令解析、业务执行、结果回传
        } finally {
            // 强制释放缓冲区，杜绝内存泄漏
            byteBuf.release();
        }
    }

    // 异常兜底：任意异常关闭通道触发重连
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        System.err.println("❌ 客户端链路异常，主动关闭通道准备重连");
        ctx.close();
    }
}

7.3 客户端启动类（全局单例、无限重连）

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

/**
 * Netty长连接客户端（支持无限自动断线重连）
 * 与上文服务端8888端口完全适配
 */
public class NettyTcpClient {
    // 服务端地址端口
    private static final String SERVER_HOST = "127.0.0.1";
    private static final int SERVER_PORT = 8888;

    // 全局单例线程组，不重复创建
    private static final NioEventLoopGroup CLIENT_GROUP = new NioEventLoopGroup();

    /**
     * 统一连接入口（供首次启动、断线重连调用）
     */
    public static void connect() {
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(CLIENT_GROUP)
                .channel(NioSocketChannel.class)
                // 开启TCP保活兜底
                .option(ChannelOption.SO_KEEPALIVE, true)
                // 关闭Nagle，实时传输心跳和报文
                .option(ChannelOption.TCP_NODELAY, true)
                .handler(new ClientChannelInitializer());

        try {
            // 异步连接，不阻塞重连任务
            ChannelFuture future = bootstrap.connect(SERVER_HOST, SERVER_PORT);
            // 监听关闭
            future.channel().closeFuture();
        } catch (Exception e) {
            System.err.println("❌ 重连失败，等待下次重试...");
        }
    }

    public static void main(String[] args) {
        // 启动客户端长连接
        NettyTcpClient.connect();
        System.out.println("✅ 长连接客户端启动完成，等待连接服务端...");
    }
}

八、客户端重连机制核心要点（生产规范）

8.1 重连避退策略

固定3秒延迟重试属于基础避退策略，短时间服务宕机仍会产生频繁请求压力。生产环境优化为指数退避重连机制：初始3秒重试，失败后6秒、12秒、24秒递增，最大间隔30秒封顶，有效避免客户端集群爆破服务端，极大提升服务稳定性。

8.2 心跳双向联动

客户端50秒主动发心跳，服务端60秒读空闲超时断线，形成完整闭环：客户端保活上报 + 服务端异常下线，彻底杜绝僵尸连接。

8.3 资源不泄露

线程组全局单例，重连不重复创建线程；ByteBuf统一release，杜绝内存泄漏。

8.4 异常闭环

无论网络异常、报文异常、主动断开，都会触发 channelInactive，自动进入重连逻辑，链路永久自愈。

九、生产级参数调优（上线必备）

所有参数为海量长连接、IoT设备、车载场景最优配置，直接复用即可，无需二次调试。

9.1 心跳参数黄金配比

• 客户端写空闲：50s（定时上报心跳，保证链路活跃）

• 服务端读空闲：60s（预留10s容错，规避网络延迟误判离线）

• 优势：完美规避网络抖动、延迟导致的误下线，同时及时清理僵尸连接

9.2 TCP内核参数优化

• TCP_NODELAY=true：关闭Nagle算法，实时传输心跳、指令、上报报文，降低延迟

• SO_KEEPALIVE=true：系统层兜底保活，配合应用层心跳双重保障

• SO_BACKLOG=1024：扩容连接队列，支持瞬时海量设备接入

9.3 线程模型配置

• BossGroup：固定1线程，仅处理连接接入，无需多线程

• WorkerGroup：默认CPU核心*2，适配读写密集型长连接业务

十、完整运行与自测流程

整套代码零配置、可独立运行、无需依赖Spring，纯Java原生Netty项目。

1. 启动服务端：运行 NettyTcpServer，监听8888端口，等待设备接入

2. 启动客户端：运行NettyTcpClient，自动建立长连接、定时上报心跳

3. 心跳自测：观察控制台，客户端50s定时发心跳，服务端持续维持在线状态

4. 断线重连自测：关闭服务端，客户端触发指数退避重连；重启服务端，自动恢复链路

5. 僵尸连接自测：客户端断网静置60s，服务端主动关闭失效通道，清理会话

十一、生产避坑终极总结（高频问题全覆盖）

• 禁止使用IP作为会话Key：多设备同IP场景冲突，必须使用Netty原生 ChannelId 唯一标识

• 禁止省略ByteBuf.release()：Netty堆外内存不主动释放，长期运行必OOM

• 禁止依赖系统TCP KeepAlive：无法识别应用层卡死、内网断流，必须自研应用心跳

• 禁止固定短间隔重连：服务宕机易引发雪崩，必须使用指数退避策略

• 必须做异常隔离：单设备报文异常、解码错误，不能击穿全局服务

• 必须清理无效会话：防止离线连接残留导致会话堆积、内存溢出

十二、扩展进阶方向（企业分布式落地）

基础单机长连接完成后，可快速迭代为企业分布式集群方案：

• Redis共享会话：解决集群多节点设备连接状态同步问题

• 消息队列解耦：报文异步入库、异步业务处理，提升并发能力

• 负载均衡：设备接入自动分配节点，实现海量连接分片

• 报文加密：AES+CRC校验，防止传输篡改、数据泄露

• 日志监控：对接ELK、Prometheus，监控在线数、心跳率、异常率

全文最终总结

本文从底层原理 - IO模型 - 核心难题 - 生产代码 - 调优避坑 - 分布式扩展，完整覆盖Java长连接开发所有技术栈。摒弃水文科普，全部为工程落地能力，整套Demo经过生产优化，支持海量并发、链路自愈、异常隔离、内存安全，可直接用于IoT、车载、IM通讯、硬件接入等所有长连接业务场景。

1. 启动 NettyTcpServer 服务端，监听8888端口

2. 启动 NettyTcpClient 客户端，自动建立长连接、定时发心跳

3. 手动关闭服务端，客户端自动打印断开日志、延迟重连

4. 重启服务端，客户端自动恢复长连接通信