[fix] 优化tcp架构

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/AbstractUdpHandleChannelHeartbeatTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 服务端 处理客户端心跳
+ * TYPE_HEARTBEAT
+ */
+
+public abstract class AbstractUdpHandleChannelHeartbeatTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+    /**
+     *
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.TYPE_HEARTBEAT.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpClientChannelActiveAdvanced.java

@@ -0,0 +1,25 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+/**
+ * 客户端通道 is active
+ */
+
+public abstract class AbstractHandleUdpClientChannelActiveAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.CLIENT_CHANNEL_ACTIVE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientCloseTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发 客户端渗透客户端init close 信息
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_CLIENT_CLOSE
+ */
+public abstract class AbstractHandleUdpDistributeClientPermeateClientCloseTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_CLOSE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientInitTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发 客户端渗透客户端init信息
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_CLIENT_INIT
+ */
+public abstract class AbstractHandleUdpDistributeClientPermeateClientInitTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_INIT.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateClientTransferCloseTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发客户端渗透客户端通信通道关闭
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE
+ */
+public abstract class AbstractHandleUdpDistributeClientPermeateClientTransferCloseTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerCloseTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发 客户端渗透服务端init close 信息
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_SERVER_CLOSE
+ */
+public abstract class AbstractHandleUdpDistributeClientPermeateServerCloseTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_SERVER_CLOSE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerInitTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发 客户端渗透服务端init信息
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_SERVER_INIT
+ */
+public abstract class AbstractHandleUdpDistributeClientPermeateServerInitTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_SERVER_INIT.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerTransferCloseTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发 客户端渗透服务端通信通道关闭
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE
+ */
+public abstract class AbstractHandleUdpDistributeClientPermeateServerTransferCloseTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientPermeateServerTransferTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发 客户端渗透服务端通信传输
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_SERVER_TRANSFER
+ */
+public abstract class AbstractHandleUdpDistributeClientPermeateServerTransferTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_SERVER_TRANSFER.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发 客户端渗透客户端数据传输通道连接成功
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+ */
+public abstract class AbstractHandleUdpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发 客户端渗透客户端数据传输通道init 成功
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+ */
+public abstract class AbstractHandleUdpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_CHANNEL_INIT_SUCCESSFUL.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferClientRequestTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发客户端渗透客户端数据传输
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_REQUEST
+ */
+public abstract class AbstractHandleUdpDistributeClientTransferClientRequestTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_REQUEST.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发 客户端渗透服务端数据传输通道连接成功
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_TRANSFER_SERVER_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+ */
+public abstract class AbstractHandleUdpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_TRANSFER_SERVER_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeClusterNodeRegisterTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发 集群注册
+ * @see MessageTypeEnums#DISTRIBUTE_CLUSTER_NODE_REGISTER_MESSAGE
+ */
+public abstract class AbstractHandleUdpDistributeClusterNodeRegisterTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLUSTER_NODE_REGISTER_MESSAGE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeConnectSuccessNotificationTypeAdvancedHandle.java

@@ -0,0 +1,23 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+/**
+ * 下发 客户端连接成功通知
+ */
+public abstract class AbstractHandleUdpDistributeConnectSuccessNotificationTypeAdvancedHandle<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_CONNECTION_SUCCESS_NOTIFICATION.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeDisconnectTypeAdvancedHandle.java

@@ -0,0 +1,26 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+/**
+ * 下发客户端断开连接通知
+ * DISTRIBUTE_CLIENT_DISCONNECTION_NOTIFICATION
+ */
+public abstract class AbstractHandleUdpDistributeDisconnectTypeAdvancedHandle<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        // 下发 客户端断开连接通知
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_DISCONNECTION_NOTIFICATION.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientRealConnectTypeAdvanced.java

@@ -0,0 +1,25 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+/**
+ * 下发 客户端 创建真实连接
+ */
+
+public abstract class AbstractHandleUdpDistributeServicePermeateClientRealConnectTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_SINGLE_CLIENT_REAL_CONNECT.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientTransferClientResponseTypeAdvanced.java

@@ -0,0 +1,28 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 下发客户端渗透客户端数据传输响应
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_RESPONSE
+ */
+public abstract class AbstractHandleUdpDistributeServicePermeateClientTransferClientResponseTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_RESPONSE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeServicePermeateClientTransferTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 客户端处理服务端下发数据
+ * DISTRIBUTE_CLIENT_TRANSFER
+ */
+public abstract class AbstractHandleUdpDistributeServicePermeateClientTransferTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_TRANSFER.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientMessageTypeAdvanced.java

@@ -0,0 +1,25 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+/**
+ * 下发 客户端关闭代理服务通道
+ */
+
+public abstract class AbstractHandleUdpDistributeSingleClientMessageTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_SINGLE_CLIENT_MESSAGE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientRealAutoReadConnectTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+/**
+ * 下发 客户端代理的真实端口自动读写
+ *
+ * @see MessageTypeEnums#DISTRIBUTE_SINGLE_CLIENT_REAL_CONNECT_AUTO_READ
+ */
+
+public abstract class AbstractHandleUdpDistributeSingleClientRealAutoReadConnectTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_SINGLE_CLIENT_REAL_CONNECT_AUTO_READ.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeSingleClientRealCloseVisitorTypeAdvanced.java

@@ -0,0 +1,25 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+/**
+ * 下发 客户端关闭代理服务通道
+ */
+
+public abstract class AbstractHandleUdpDistributeSingleClientRealCloseVisitorTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_SINGLE_CLIENT_REAL_CLOSE_VISITOR.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeStagingClosedTypeAdvanced.java

@@ -0,0 +1,25 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+/**
+ * 下发 客户端暂存关闭
+ */
+
+public abstract class AbstractHandleUdpDistributeStagingClosedTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_STAGING_CLOSED_NOTIFICATION.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/client/AbstractHandleUdpDistributeStagingOpenedTypeAdvanced.java

@@ -0,0 +1,25 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.client;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+/**
+ * 下发 客户端暂存开启
+ */
+
+public abstract class AbstractHandleUdpDistributeStagingOpenedTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.DISTRIBUTE_CLIENT_STAGING_OPENED_NOTIFICATION.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpClientConnectSuccessTypeAdvanced.java

@@ -0,0 +1,25 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+/**
+ * 服务端处理客户端连接成功
+ */
+public abstract class AbstractHandleUdpClientConnectSuccessTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg>
+        implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_CONNECT_SUCCESS.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientCloseTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报 客户端渗透客户端init close 信息
+ * REPORT_CLIENT_PERMEATE_CLIENT_CLOSE
+ */
+public abstract class AbstractHandleUdpReportClientPermeateClientCloseTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_PERMEATE_CLIENT_CLOSE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientInitTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报 客户端渗透客户端init信息
+ * REPORT_CLIENT_PERMEATE_CLIENT_INIT
+ */
+public abstract class AbstractHandleUdpReportClientPermeateClientInitTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_PERMEATE_CLIENT_INIT.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateClientTransferCloseTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报客户端渗透客户端通信通道关闭
+ *@see  MessageTypeEnums#REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE
+ */
+public abstract class AbstractHandleUdpReportClientPermeateClientTransferCloseTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerCloseTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报 客户端渗透服务端init close 信息
+ * REPORT_CLIENT_PERMEATE_SERVER_CLOSE
+ */
+public abstract class AbstractHandleUdpReportClientPermeateServerCloseTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_PERMEATE_SERVER_CLOSE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerInitTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报 客户端渗透服务端init信息
+ * REPORT_CLIENT_PERMEATE_SERVER_INIT
+ */
+public abstract class AbstractHandleUdpReportClientPermeateServerInitTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_PERMEATE_SERVER_INIT.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerTransferCloseTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报 客户端渗透服务端通信通道关闭
+ * REPORT_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE
+ */
+public abstract class AbstractHandleUdpReportClientPermeateServerTransferCloseTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientPermeateServerTransferTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报 客户端渗透服务端通信
+ * REPORT_CLIENT_PERMEATE_SERVER_TRANSFER
+ */
+public abstract class AbstractHandleUdpReportClientPermeateServerTransferTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_PERMEATE_SERVER_TRANSFER.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报 客户端渗透客户端数据传输通道连接成功
+ * REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+ */
+public abstract class AbstractHandleUdpReportClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报 客户端渗透客户端数据传输通道init
+ * REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CHANNEL_INIT_SUCCESSFUL
+ */
+public abstract class AbstractHandleUdpReportClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_INIT_SUCCESSFUL.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientResponseTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报客户端渗透客户端数据传输结果
+ * REPORT_CLIENT_TRANSFER_CLIENT_RESPONSE
+ */
+public abstract class AbstractHandleUdpReportClientTransferClientResponseTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_RESPONSE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferClientTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报客户端渗透客户端数据传输
+ * REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_REQUEST
+ */
+public abstract class AbstractHandleUdpReportClientTransferClientTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_TRANSFER_CLIENT_REQUEST.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报 客户端渗透服务端数据传输通道连接成功
+ * REPORT_CLIENT_TRANSFER_SERVER_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+ */
+public abstract class AbstractHandleUdpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_TRANSFER_SERVER_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportClusterNodeRegisterTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 上报 集群注册
+ * REPORT_CLUSTER_NODE_REGISTER_MESSAGE
+ */
+public abstract class AbstractHandleUdpReportClusterNodeRegisterTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLUSTER_NODE_REGISTER_MESSAGE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportDisconnectTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+/**
+ * 客户端上报断开连接通知
+ * DISTRIBUTE_CLIENT_DISCONNECTION_NOTIFICATION
+ */
+
+public abstract class AbstractHandleUdpReportDisconnectTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        // 下发 客户端断开连接通知
+        return MessageTypeEnums.REPORT_CLIENT_DISCONNECTION.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServerChannelActiveTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 服务端通道 is active
+ * SERVER_CHANNEL_ACTIVE
+ */
+public abstract class AbstractHandleUdpReportServerChannelActiveTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.SERVER_CHANNEL_ACTIVE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientCloseVisitorTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 服务端处理客户端 关闭一个访客
+ * REPORT_SERVICE_PERMEATE_CLIENT_CLIENT_CLOSE_VISITOR
+ */
+public abstract class AbstractHandleUdpReportServicePermeateClientCloseVisitorTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_SINGLE_CLIENT_CLOSE_VISITOR.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientRealConnectTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 服务端处理客户端绑定真实服务成功
+ * REPORT_SINGLE_CLIENT_REAL_CONNECT
+ */
+public abstract class AbstractHandleUdpReportServicePermeateClientRealConnectTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_SINGLE_CLIENT_REAL_CONNECT.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportServicePermeateClientTransferTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 服务端处理客户端上报数据
+ * REPORT_CLIENT_STAGING_CLOSED
+ */
+public abstract class AbstractHandleUdpReportServicePermeateClientTransferTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_TRANSFER.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportSingleClientMessage2OtherClientTypeAdvanced.java

@@ -0,0 +1,27 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+
+/**
+ * 服务端处理客户端 关闭一个访客
+ * REPORT_SERVICE_PERMEATE_CLIENT_CLIENT_CLOSE_VISITOR
+ */
+public abstract class AbstractHandleUdpReportSingleClientMessage2OtherClientTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_SINGLE_CLIENT_MESSAGE.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportStagingClosedTypeAdvanced.java

@@ -0,0 +1,29 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+/**
+ * 客户端暂存通知
+ * 客户端离线后陷入暂存服务业务上使用
+ * 云端发送的消息，此模式云端后者说服务端不需要处理
+ * CLIENT_STAGING
+ * 客户端上报暂存
+ */
+
+public abstract class AbstractHandleUdpReportStagingClosedTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_STAGING_CLOSED.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-common/src/main/java/org/framework/lazy/cloud/network/heartbeat/common/advanced/udp/server/AbstractHandleUdpReportStagingOpenedTypeAdvanced.java

@@ -0,0 +1,25 @@
+package org.framework.lazy.cloud.network.heartbeat.common.advanced.udp.server;
+
+
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.AbstractHandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+
+/**
+ * 上报客户端暂存开启
+ */
+
+public abstract class AbstractHandleUdpReportStagingOpenedTypeAdvanced<MSG> extends AbstractHandleChannelTypeAdvanced<NettyProxyMsg> implements HandleChannelTypeAdvanced {
+
+    /**
+     * 是否支持当前类型
+     *
+     * @param msg 通道数据
+     * @return 布尔类型 是、否
+     */
+    @Override
+    public boolean doSupport(NettyProxyMsg msg) {
+        return MessageTypeEnums.REPORT_CLIENT_STAGING_OPENED.getTypeByte() == msg.getType();
+    }
+}

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/config/HeartbeatServerConfiguration.java

@@ -16,12 +16,12 @@ public class HeartbeatServerConfiguration {
     /**
      * 服务端 处理客户端心跳
      *
-     * @return ServerTcpTcpHandleChannelHeartbeatTypeAdvanced
+     * @return ServerHandleTcpChannelHeartbeatTypeAdvanced
      */
     @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
     @Bean
-    public ServerTcpTcpHandleChannelHeartbeatTypeAdvanced serverChannelHeartbeatTypeAdvanced() {
+    public ServerHandleTcpChannelHeartbeatTypeAdvanced serverChannelHeartbeatTypeAdvanced() {
-        return new ServerTcpTcpHandleChannelHeartbeatTypeAdvanced();
+        return new ServerHandleTcpChannelHeartbeatTypeAdvanced();
     }
 
     /**

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/context/NettyTcpServerSocketApplicationListener.java

@@ -6,7 +6,7 @@ import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import jakarta.annotation.PreDestroy;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerFilter;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerFilter;
 import org.framework.lazy.cloud.network.heartbeat.server.properties.ServerNodeProperties;
 import org.springframework.boot.context.event.ApplicationStartedEvent;
 import org.springframework.context.ApplicationListener;
@@ -18,12 +18,12 @@ public class NettyTcpServerSocketApplicationListener implements ApplicationListe
 
     private final EventLoopGroup bossGroup = new NioEventLoopGroup();
     private final EventLoopGroup workerGroup = new NioEventLoopGroup();
-    private final NettyServerFilter nettyServerFilter;// 通道业务处理
+    private final NettyTcpServerFilter nettyTcpServerFilter;// 通道业务处理
     private ChannelFuture channelFuture;
     private final ServerNodeProperties serverNodeProperties;
 
-    public NettyTcpServerSocketApplicationListener(NettyServerFilter nettyServerFilter, ServerNodeProperties serverNodeProperties) {
+    public NettyTcpServerSocketApplicationListener(NettyTcpServerFilter nettyTcpServerFilter, ServerNodeProperties serverNodeProperties) {
-        this.nettyServerFilter = nettyServerFilter;
+        this.nettyTcpServerFilter = nettyTcpServerFilter;
         this.serverNodeProperties = serverNodeProperties;
     }
 
@@ -52,7 +52,7 @@ public class NettyTcpServerSocketApplicationListener implements ApplicationListe
 //                    .childOption(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT
                     .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2))
 
-                    .childHandler(nettyServerFilter);
+                    .childHandler(nettyTcpServerFilter);
             channelFuture = b.bind(tcpPort).sync();
 
             channelFuture.addListener((ChannelFutureListener) channelFuture -> {

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/context/NettyUdpServerSocketApplicationListener.java

@@ -9,7 +9,7 @@ import io.netty.channel.socket.nio.NioDatagramChannel;
 import io.netty.util.internal.SystemPropertyUtil;
 import jakarta.annotation.PreDestroy;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerFilter;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerFilter;
 import org.framework.lazy.cloud.network.heartbeat.server.properties.ServerNodeProperties;
 import org.springframework.boot.context.event.ApplicationStartedEvent;
 import org.springframework.context.ApplicationListener;
@@ -20,12 +20,12 @@ import org.springframework.stereotype.Component;
 public class NettyUdpServerSocketApplicationListener implements ApplicationListener<ApplicationStartedEvent> {
 
     private final EventLoopGroup bossGroup = "linux".equalsIgnoreCase(SystemPropertyUtil.get("os.name")) ? new EpollEventLoopGroup() : new NioEventLoopGroup();
-    private final NettyServerFilter nettyServerFilter;// 通道业务处理
+    private final NettyTcpServerFilter nettyTcpServerFilter;// 通道业务处理
     private ChannelFuture channelFuture;
     private final ServerNodeProperties serverNodeProperties;
 
-    public NettyUdpServerSocketApplicationListener(NettyServerFilter nettyServerFilter, ServerNodeProperties serverNodeProperties) {
+    public NettyUdpServerSocketApplicationListener(NettyTcpServerFilter nettyTcpServerFilter, ServerNodeProperties serverNodeProperties) {
-        this.nettyServerFilter = nettyServerFilter;
+        this.nettyTcpServerFilter = nettyTcpServerFilter;
         this.serverNodeProperties = serverNodeProperties;
     }
 
@@ -59,7 +59,7 @@ public class NettyUdpServerSocketApplicationListener implements ApplicationListe
                     .option(ChannelOption.SO_RCVBUF, 1024 * 1024 * 10)
                     //发送缓存区  10M
                     .option(ChannelOption.SO_SNDBUF, 1024 * 1024 * 10)
-                    .handler(nettyServerFilter);
+                    .handler(nettyTcpServerFilter);
             channelFuture = b.bind(udpPort).sync();
 
             channelFuture.addListener((ChannelFutureListener) channelFuture -> {

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/init/InitServerSocket.java

@@ -4,7 +4,7 @@ package org.framework.lazy.cloud.network.heartbeat.server.init;
 import lombok.extern.slf4j.Slf4j;
 import org.framework.lazy.cloud.network.heartbeat.server.context.NettyTcpServerSocketApplicationListener;
 import org.framework.lazy.cloud.network.heartbeat.server.context.NettyUdpServerSocketApplicationListener;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerFilter;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerFilter;
 import org.framework.lazy.cloud.network.heartbeat.server.properties.ServerNodeProperties;
 import org.springframework.boot.CommandLineRunner;
 import org.springframework.boot.autoconfigure.web.ServerProperties;
@@ -28,7 +28,7 @@ import java.util.concurrent.TimeUnit;
 public class InitServerSocket implements CommandLineRunner {
 
     private final ServerProperties serverProperties;
-    private final NettyServerFilter nettyServerFilter;
+    private final NettyTcpServerFilter nettyTcpServerFilter;
     private final ServerNodeProperties serverNodeProperties;
 
 
@@ -36,11 +36,11 @@ public class InitServerSocket implements CommandLineRunner {
             new ArrayBlockingQueue<>(1));
 
     public InitServerSocket(ServerProperties serverProperties,
-                            NettyServerFilter nettyServerFilter,
+                            NettyTcpServerFilter nettyTcpServerFilter,
                             ServerNodeProperties serverNodeProperties
     ) {
         this.serverProperties = serverProperties;
-        this.nettyServerFilter = nettyServerFilter;
+        this.nettyTcpServerFilter = nettyTcpServerFilter;
         this.serverNodeProperties = serverNodeProperties;
     }
 

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpChannelHeartbeatTypeAdvanced.java

@@ -16,7 +16,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
  */
 @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Component
-public class ServerTcpTcpHandleChannelHeartbeatTypeAdvanced extends AbstractTcpHandleChannelHeartbeatTypeAdvanced<NettyProxyMsg> {
+public class ServerHandleTcpChannelHeartbeatTypeAdvanced extends AbstractTcpHandleChannelHeartbeatTypeAdvanced<NettyProxyMsg> {
 
     /**
      * 处理当前数据

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java

@@ -4,7 +4,7 @@ import io.netty.channel.Channel;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.server.AbstractHandleTcpReportClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyClientPermeateServerConnectRealSocket;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyTcpClientPermeateServerConnectRealSocket;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.context.annotation.Role;
 import org.springframework.stereotype.Component;
@@ -33,7 +33,7 @@ public class ServerHandleTcpReportClientTransferServerPermeateChannelConnectionS
         // 绑定客户端ID
         ChannelAttributeKeyUtils.buildClientId(transferChannel,clientId);
         ChannelAttributeKeyUtils.buildVisitorId(transferChannel,msgVisitorId);
-        NettyClientPermeateServerConnectRealSocket.buildNewRealServer(new String(msgVisitorId),
+        NettyTcpClientPermeateServerConnectRealSocket.buildNewRealServer(new String(msgVisitorId),
                 Integer.parseInt(new String(msgVisitorPort)),
                 new String(msgClientTargetIp),
                 Integer.parseInt(new String(msgClientTargetPort)),

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/advanced/ServerHandleTcpReportDisconnectTypeAdvanced.java

@@ -9,7 +9,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.NettyClientVisitorConte
 import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.server.AbstractHandleTcpReportDisconnectTypeAdvanced;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyServerPermeateClientVisitorSocket;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyTcpServerPermeateClientVisitorSocket;
 import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.LazyClientStatsChangeApplication;
 import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.command.lazy.netty.client.state.LazyNettyClientLoginCommand;
 import org.springframework.beans.factory.config.BeanDefinition;
@@ -80,9 +80,9 @@ public class ServerHandleTcpReportDisconnectTypeAdvanced extends AbstractHandleT
 
             });
             // 关闭绑定的访客端口
-            List<NettyServerPermeateClientVisitorSocket> visitorSockets = NettyClientVisitorContext.getVisitorSockets(new String(clientId));
+            List<NettyTcpServerPermeateClientVisitorSocket> visitorSockets = NettyClientVisitorContext.getVisitorSockets(new String(clientId));
             if (!ObjectUtils.isEmpty(visitorSockets)) {
-                for (NettyServerPermeateClientVisitorSocket visitorSocket : visitorSockets) {
+                for (NettyTcpServerPermeateClientVisitorSocket visitorSocket : visitorSockets) {
                     int visitorPort = visitorSocket.getVisitorPort();
                     visitorSocket.close();
                     log.warn("client :[{}] visitorPort:[{}] close", new String(clientId), visitorPort);

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpClientPermeateServerRealFilter.java

@@ -5,12 +5,12 @@ import io.netty.channel.socket.SocketChannel;
 import org.framework.lazy.cloud.network.heartbeat.common.decoder.TransferDecoder;
 import org.framework.lazy.cloud.network.heartbeat.common.encoder.TransferEncoder;
 import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyClientPermeateServerRealHandler;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyTcpClientPermeateServerRealHandler;
 
 /**
  * 客户端渗透服务端
  */
-public class ClientPermeateServerRealFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyTcpClientPermeateServerRealFilter extends DebugChannelInitializer<SocketChannel> {
     /**
      * This method will be called once the {@link Channel} was registered. After the method returns this instance
      * will be removed from the {@link ChannelPipeline} of the {@link Channel}.
@@ -23,7 +23,7 @@ public class ClientPermeateServerRealFilter extends DebugChannelInitializer<Sock
         // 解码、编码
         pipeline.addLast(new TransferDecoder(Integer.MAX_VALUE, 1024 * 1024*10));
         pipeline.addLast(new TransferEncoder());
-        pipeline.addLast(new NettyClientPermeateServerRealHandler());
+        pipeline.addLast(new NettyTcpClientPermeateServerRealHandler());
 
     }
 }

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerFilter.java

@@ -6,7 +6,7 @@ import io.netty.handler.codec.string.StringDecoder;
 import io.netty.handler.codec.string.StringEncoder;
 import io.netty.handler.timeout.IdleStateHandler;
 import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyServerHandler;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyTcpServerHandler;
 import org.springframework.stereotype.Component;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter;
 import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
@@ -23,10 +23,10 @@ import java.util.concurrent.TimeUnit;
  * @date 2023/09/13 10:26
  */
 @Component
-public class NettyServerFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyTcpServerFilter extends DebugChannelInitializer<SocketChannel> {
     private final List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList;
 
-    public NettyServerFilter(List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList) {
+    public NettyTcpServerFilter(List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList) {
         this.handleChannelTypeAdvancedList = handleChannelTypeAdvancedList;
     }
 
@@ -46,7 +46,7 @@ public class NettyServerFilter extends DebugChannelInitializer<SocketChannel> {
         pipeline.addLast("encoder", new StringEncoder());
         // 类型处理器适配器
         ChannelTypeAdapter channelTypeAdapter = new ChannelTypeAdapter(handleChannelTypeAdvancedList);
-        pipeline.addLast("doHandler", new NettyServerHandler(channelTypeAdapter));// 服务端业务逻辑
+        pipeline.addLast("doHandler", new NettyTcpServerHandler(channelTypeAdapter));// 服务端业务逻辑
 
 
 

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateClientVisitorFilter.java

@@ -8,13 +8,13 @@ import io.netty.channel.socket.SocketChannel;
 import org.framework.lazy.cloud.network.heartbeat.common.InternalNetworkPenetrationRealClient;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter;
 import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyServerPermeateClientVisitorHandler;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyTcpServerPermeateClientVisitorHandler;
 
-public class NettyServerPermeateClientVisitorFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyTcpServerPermeateClientVisitorFilter extends DebugChannelInitializer<SocketChannel> {
     private final InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient;
     private final ChannelFlowAdapter channelFlowAdapter;
 
-    public NettyServerPermeateClientVisitorFilter(InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient, ChannelFlowAdapter channelFlowAdapter) {
+    public NettyTcpServerPermeateClientVisitorFilter(InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient, ChannelFlowAdapter channelFlowAdapter) {
         this.internalNetworkPenetrationRealClient = internalNetworkPenetrationRealClient;
         this.channelFlowAdapter = channelFlowAdapter;
     }
@@ -32,6 +32,6 @@ public class NettyServerPermeateClientVisitorFilter extends DebugChannelInitiali
     protected void initChannel0(SocketChannel ch) throws Exception {
         ChannelPipeline pipeline = ch.pipeline();
         pipeline.addLast(new ChannelDuplexHandler());
-        pipeline.addLast(new NettyServerPermeateClientVisitorHandler(internalNetworkPenetrationRealClient, channelFlowAdapter));
+        pipeline.addLast(new NettyTcpServerPermeateClientVisitorHandler(internalNetworkPenetrationRealClient, channelFlowAdapter));
     }
 }

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateServerRealFilter.java

@@ -11,13 +11,13 @@ import org.framework.lazy.cloud.network.heartbeat.common.InternalNetworkServerPe
 import org.framework.lazy.cloud.network.heartbeat.common.decoder.TransferDecoder;
 import org.framework.lazy.cloud.network.heartbeat.common.encoder.TransferEncoder;
 import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyServerPermeateServerRealHandler;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyTcpServerPermeateServerRealHandler;
 
 @Slf4j
-public class NettyServerPermeateServerRealFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyTcpServerPermeateServerRealFilter extends DebugChannelInitializer<SocketChannel> {
     private final InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer;
 
-    public NettyServerPermeateServerRealFilter(InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer) {
+    public NettyTcpServerPermeateServerRealFilter(InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer) {
         this.internalNetworkServerPermeateServerRealServer = internalNetworkServerPermeateServerRealServer;
     }
 
@@ -48,7 +48,7 @@ public class NettyServerPermeateServerRealFilter extends DebugChannelInitializer
         // 解码、编码
         pipeline.addLast(new TransferDecoder(Integer.MAX_VALUE, 1024 * 1024*10));
         pipeline.addLast(new TransferEncoder());
-        pipeline.addLast(new NettyServerPermeateServerRealHandler());
+        pipeline.addLast(new NettyTcpServerPermeateServerRealHandler());
 
     }
 }

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/filter/NettyTcpServerPermeateServerVisitorFilter.java

@@ -8,13 +8,13 @@ import io.netty.channel.socket.SocketChannel;
 import org.framework.lazy.cloud.network.heartbeat.common.InternalNetworkServerPermeateServerRealServer;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter;
 import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyServerPermeateServerVisitorHandler;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler.NettyTcpServerPermeateServerVisitorHandler;
 
-public class NettyServerPermeateServerVisitorFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyTcpServerPermeateServerVisitorFilter extends DebugChannelInitializer<SocketChannel> {
     private final InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer;
     private final ChannelFlowAdapter channelFlowAdapter;
 
-    public NettyServerPermeateServerVisitorFilter(InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer, ChannelFlowAdapter channelFlowAdapter) {
+    public NettyTcpServerPermeateServerVisitorFilter(InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer, ChannelFlowAdapter channelFlowAdapter) {
         this.internalNetworkServerPermeateServerRealServer = internalNetworkServerPermeateServerRealServer;
         this.channelFlowAdapter = channelFlowAdapter;
     }
@@ -32,6 +32,6 @@ public class NettyServerPermeateServerVisitorFilter extends DebugChannelInitiali
     protected void initChannel0(SocketChannel ch) throws Exception {
         ChannelPipeline pipeline = ch.pipeline();
         pipeline.addLast(new ChannelDuplexHandler());
-        pipeline.addLast(new NettyServerPermeateServerVisitorHandler(internalNetworkServerPermeateServerRealServer, channelFlowAdapter));
+        pipeline.addLast(new NettyTcpServerPermeateServerVisitorHandler(internalNetworkServerPermeateServerRealServer, channelFlowAdapter));
     }
 }

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/HeartBeatServerHandler.java

@@ -1,44 +0,0 @@
-package org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.handler;
-
-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.AttributeKey;
-
-@Deprecated
-public class HeartBeatServerHandler extends ChannelInboundHandlerAdapter {
-
-    AttributeKey<String> channelAttributeKeyId = AttributeKey.valueOf("channelAttributeTenantId");
-    private int lossConnectCount = 0;
-
-    @Override
-    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
-        String channelAttributeId = ctx.channel().attr(channelAttributeKeyId).get();
-        System.out.println("channelAttributeTenantId:" + channelAttributeId);
-        System.out.println("已经5秒未收到客户端的消息了！");
-
-        if (evt instanceof IdleStateEvent event) {
-            if (event.state() == IdleState.READER_IDLE) {
-                lossConnectCount++;
-                if (lossConnectCount > 2) {
-                    System.out.println("关闭这个不活跃通道！");
-//                    ctx.channel().connectionClose();
-                }
-            }
-        } else {
-            super.userEventTriggered(ctx, evt);
-        }
-    }
-
-    @Override
-    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
-        lossConnectCount = 0;
-        System.out.println("client says: " + msg.toString());
-    }
-
-    @Override
-    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
-        ctx.close();
-    }
-}

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/LazyTcpServerIdleStateHandler.java

@@ -33,7 +33,7 @@ import java.util.concurrent.TimeUnit;
  *
  * public class MyChannelInitializer extends {@link ChannelInitializer}<{@link Channel}> {
  *     public void initChannel({@link Channel} channel) {
- *         channel.pipeline().addLast("readTimeoutHandler", new {@link LazyServerIdleStateHandler}(30));
+ *         channel.pipeline().addLast("readTimeoutHandler", new {@link LazyTcpServerIdleStateHandler}(30));
  *         channel.pipeline().addLast("myHandler", new MyHandler());
  *     }
  * }
@@ -60,7 +60,7 @@ import java.util.concurrent.TimeUnit;
  * @see WriteTimeoutHandler
  * @see IdleStateHandler
  */
-public class LazyServerIdleStateHandler extends ChannelDuplexHandler {
+public class LazyTcpServerIdleStateHandler extends ChannelDuplexHandler {
     private static final long MIN_TIMEOUT_NANOS = TimeUnit.MILLISECONDS.toNanos(1);
     private final boolean observeOutput;
     private final long readerIdleTimeNanos;
@@ -103,7 +103,7 @@ public class LazyServerIdleStateHandler extends ChannelDuplexHandler {
      *                              will be triggered when neither read nor write was performed for
      *                              the specified period of time.  Specify {@code 0} to disable.
      */
-    public LazyServerIdleStateHandler(
+    public LazyTcpServerIdleStateHandler(
             int readerIdleTimeSeconds,
             int writerIdleTimeSeconds,
             int allIdleTimeSeconds) {
@@ -113,9 +113,9 @@ public class LazyServerIdleStateHandler extends ChannelDuplexHandler {
     }
 
     /**
-     * @see #LazyServerIdleStateHandler(boolean, long, long, long, TimeUnit)
+     * @see #LazyTcpServerIdleStateHandler(boolean, long, long, long, TimeUnit)
      */
-    public LazyServerIdleStateHandler(
+    public LazyTcpServerIdleStateHandler(
             long readerIdleTime, long writerIdleTime, long allIdleTime,
             TimeUnit unit) {
         this(false, readerIdleTime, writerIdleTime, allIdleTime, unit);
@@ -138,9 +138,9 @@ public class LazyServerIdleStateHandler extends ChannelDuplexHandler {
      * @param unit           the {@link TimeUnit} of {@code readerIdleTime},
      *                       {@code writeIdleTime}, and {@code allIdleTime}
      */
-    public LazyServerIdleStateHandler(boolean observeOutput,
+    public LazyTcpServerIdleStateHandler(boolean observeOutput,
-                                      long readerIdleTime, long writerIdleTime, long allIdleTime,
+                                         long readerIdleTime, long writerIdleTime, long allIdleTime,
-                                      TimeUnit unit) {
+                                         TimeUnit unit) {
         ObjectUtil.checkNotNull(unit, "unit");
 
         this.observeOutput = observeOutput;
@@ -470,7 +470,7 @@ public class LazyServerIdleStateHandler extends ChannelDuplexHandler {
         @Override
         protected void run(ChannelHandlerContext ctx) {
 
-            long lastWriteTime = LazyServerIdleStateHandler.this.lastWriteTime;
+            long lastWriteTime = LazyTcpServerIdleStateHandler.this.lastWriteTime;
             long nextDelay = writerIdleTimeNanos - (ticksInNanos() - lastWriteTime);
             if (nextDelay <= 0) {
                 // Writer is idle - set a new timeout and notify the callback.

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpClientPermeateServerRealHandler.java

@@ -19,7 +19,7 @@ import org.wu.framework.spring.utils.SpringContextHolder;
  * 客户端渗透服务端
  */
 @Slf4j
-public class NettyClientPermeateServerRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
+public class NettyTcpClientPermeateServerRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
 
 
     @Override

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerHandler.java

@@ -19,7 +19,7 @@ import org.wu.framework.core.utils.ObjectUtils;
  * @date 2023/09/13 10:27
  */
 @Slf4j
-public class NettyServerHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
+public class NettyTcpServerHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
 
     private final ChannelTypeAdapter channelTypeAdapter;
     /**
@@ -31,7 +31,7 @@ public class NettyServerHandler extends SimpleChannelInboundHandler<NettyProxyMs
      */
     private int transfer_count = 1;
 
-    public NettyServerHandler(ChannelTypeAdapter channelTypeAdapter) {
+    public NettyTcpServerHandler(ChannelTypeAdapter channelTypeAdapter) {
         this.channelTypeAdapter = channelTypeAdapter;
     }
 

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerPermeateClientVisitorHandler.java

@@ -18,12 +18,12 @@ import org.wu.framework.core.utils.ObjectUtils;
 import java.util.UUID;
 
 @Slf4j
-public class NettyServerPermeateClientVisitorHandler extends SimpleChannelInboundHandler<ByteBuf> {
+public class NettyTcpServerPermeateClientVisitorHandler extends SimpleChannelInboundHandler<ByteBuf> {
     private final InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient;
     private final ChannelFlowAdapter channelFlowAdapter;// 流量适配器
 //    private final NettyChannelPool nettyChannelPool = new DefaultNettyChannelPool(10);
 
-    public NettyServerPermeateClientVisitorHandler(InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient, ChannelFlowAdapter channelFlowAdapter) {
+    public NettyTcpServerPermeateClientVisitorHandler(InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient, ChannelFlowAdapter channelFlowAdapter) {
         this.internalNetworkPenetrationRealClient = internalNetworkPenetrationRealClient;
         this.channelFlowAdapter = channelFlowAdapter;
     }

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerPermeateServerRealHandler.java

@@ -14,7 +14,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeK
  * 来自客户端 真实服务器返回的数据请求
  */
 @Slf4j
-public class NettyServerPermeateServerRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
+public class NettyTcpServerPermeateServerRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
 
     @Override
     public void channelActive(ChannelHandlerContext ctx) throws Exception {

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/handler/NettyTcpServerPermeateServerVisitorHandler.java

@@ -12,17 +12,17 @@ import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdap
 import org.framework.lazy.cloud.network.heartbeat.common.enums.ChannelFlowEnum;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
 import org.framework.lazy.cloud.network.heartbeat.server.netty.flow.ServerChannelFlow;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyServerPermeateServerConnectRealSocket;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyTcpServerPermeateServerConnectRealSocket;
 
 import java.util.UUID;
 
 @Slf4j
-public class NettyServerPermeateServerVisitorHandler extends SimpleChannelInboundHandler<ByteBuf> {
+public class NettyTcpServerPermeateServerVisitorHandler extends SimpleChannelInboundHandler<ByteBuf> {
     private final InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer;
     private final ChannelFlowAdapter channelFlowAdapter;// 流量适配器
 //    private final NettyChannelPool nettyChannelPool = new DefaultNettyChannelPool(10);
 
-    public NettyServerPermeateServerVisitorHandler(InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer, ChannelFlowAdapter channelFlowAdapter) {
+    public NettyTcpServerPermeateServerVisitorHandler(InternalNetworkServerPermeateServerRealServer internalNetworkServerPermeateServerRealServer, ChannelFlowAdapter channelFlowAdapter) {
         this.internalNetworkServerPermeateServerRealServer = internalNetworkServerPermeateServerRealServer;
         this.channelFlowAdapter = channelFlowAdapter;
     }
@@ -45,7 +45,7 @@ public class NettyServerPermeateServerVisitorHandler extends SimpleChannelInboun
         log.info("开始准备绑定渗透真实通道: {}", internalNetworkServerPermeateServerRealServer.getVisitorPort());
         // 创建这是客户端通道池
 
-        NettyServerPermeateServerConnectRealSocket.buildRealServer(internalNetworkServerPermeateServerRealServer, visitorChannel, visitorId);
+        NettyTcpServerPermeateServerConnectRealSocket.buildRealServer(internalNetworkServerPermeateServerRealServer, visitorChannel, visitorId);
 
         log.info("内网渗透 服务端访客端口连接成功了");
 

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyOnCloudNettyServerSocket.java

@@ -6,7 +6,7 @@ import io.netty.channel.*;
 import io.netty.channel.nio.NioEventLoopGroup;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import org.framework.lazy.cloud.network.heartbeat.server.context.NettyTcpServerSocketApplicationListener;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerFilter;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerFilter;
 
 
 /**
@@ -16,11 +16,11 @@ import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyS
 public class NettyOnCloudNettyServerSocket {
     private final EventLoopGroup bossGroup = new NioEventLoopGroup();
     private final EventLoopGroup workerGroup = new NioEventLoopGroup();
-    private final NettyServerFilter nettyServerFilter;// 通道业务处理
+    private final NettyTcpServerFilter nettyTcpServerFilter;// 通道业务处理
     private ChannelFuture channelFuture;
 
-    public NettyOnCloudNettyServerSocket(NettyServerFilter nettyServerFilter) {
+    public NettyOnCloudNettyServerSocket(NettyTcpServerFilter nettyTcpServerFilter) {
-        this.nettyServerFilter = nettyServerFilter;
+        this.nettyTcpServerFilter = nettyTcpServerFilter;
     }
 
     /**
@@ -45,7 +45,7 @@ public class NettyOnCloudNettyServerSocket {
 //                    .childOption(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT
                     .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2))
 
-                    .childHandler(nettyServerFilter);
+                    .childHandler(nettyTcpServerFilter);
             channelFuture = b.bind(serverPort).sync();
 
             channelFuture.addListener((ChannelFutureListener) channelFuture -> {

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpClientPermeateServerConnectRealSocket.java

@@ -9,7 +9,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.framework.lazy.cloud.network.heartbeat.common.MessageType;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.ClientPermeateServerRealFilter;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpClientPermeateServerRealFilter;
 
 import java.util.concurrent.TimeUnit;
 
@@ -17,7 +17,7 @@ import java.util.concurrent.TimeUnit;
  * 客户端渗透服务端 连接真实通道
  */
 @Slf4j
-public class NettyClientPermeateServerConnectRealSocket {
+public class NettyTcpClientPermeateServerConnectRealSocket {
     private static final EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
 
 
@@ -38,7 +38,7 @@ public class NettyClientPermeateServerConnectRealSocket {
 //                    .option(ChannelOption.SO_BACKLOG, 128)//务端接受连接的队列长度 默认128
 //                    .option(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT
                     .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2))
-                    .handler(new ClientPermeateServerRealFilter())
+                    .handler(new NettyTcpClientPermeateServerRealFilter())
 
             ;
 

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateClientVisitorSocket.java

@@ -11,7 +11,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.NettyClientVisitorConte
 import org.framework.lazy.cloud.network.heartbeat.common.NettyVisitorPortContext;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter;
 import org.framework.lazy.cloud.network.heartbeat.common.socket.PermeateVisitorSocket;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerPermeateClientVisitorFilter;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerPermeateClientVisitorFilter;
 
 /**
  * 内网穿透服务端访客通道
@@ -20,17 +20,17 @@ import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyS
  * @see NettyClientVisitorContext
  */
 @Slf4j
-public class NettyServerPermeateClientVisitorSocket implements PermeateVisitorSocket {
+public class NettyTcpServerPermeateClientVisitorSocket implements PermeateVisitorSocket {
     private final EventLoopGroup bossGroup = new NioEventLoopGroup();
     private final EventLoopGroup workerGroup = new NioEventLoopGroup();
-    private final NettyServerPermeateClientVisitorFilter nettyServerPermeateClientVisitorFilter;
+    private final NettyTcpServerPermeateClientVisitorFilter nettyTcpServerPermeateClientVisitorFilter;
     @Getter
     private final String clientId;
     @Getter
     private final int visitorPort;
 
-    public NettyServerPermeateClientVisitorSocket(NettyServerPermeateClientVisitorFilter nettyServerPermeateClientVisitorFilter, String clientId, int visitorPort) {
+    public NettyTcpServerPermeateClientVisitorSocket(NettyTcpServerPermeateClientVisitorFilter nettyTcpServerPermeateClientVisitorFilter, String clientId, int visitorPort) {
-        this.nettyServerPermeateClientVisitorFilter = nettyServerPermeateClientVisitorFilter;
+        this.nettyTcpServerPermeateClientVisitorFilter = nettyTcpServerPermeateClientVisitorFilter;
         this.clientId = clientId;
         this.visitorPort = visitorPort;
     }
@@ -64,7 +64,7 @@ public class NettyServerPermeateClientVisitorSocket implements PermeateVisitorSo
                     .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2))
 
 
-                    .childHandler(nettyServerPermeateClientVisitorFilter);
+                    .childHandler(nettyTcpServerPermeateClientVisitorFilter);
             try {
                 bootstrap.bind(visitorPort).sync().addListener((ChannelFutureListener) future -> {
                     if (future.isSuccess()) {
@@ -211,7 +211,7 @@ public class NettyServerPermeateClientVisitorSocket implements PermeateVisitorSo
             return this;
         }
 
-        public NettyServerPermeateClientVisitorSocket build() {
+        public NettyTcpServerPermeateClientVisitorSocket build() {
             if (clientId == null) {
                 throw new IllegalArgumentException("clientId must not null");
             }
@@ -232,8 +232,8 @@ public class NettyServerPermeateClientVisitorSocket implements PermeateVisitorSo
                     .visitorPort(visitorPort)
                     .visitorId(visitorId).build();
 
-            NettyServerPermeateClientVisitorFilter nettyServerPermeateClientVisitorFilter = new NettyServerPermeateClientVisitorFilter(internalNetworkPenetrationRealClient, channelFlowAdapter);
+            NettyTcpServerPermeateClientVisitorFilter nettyTcpServerPermeateClientVisitorFilter = new NettyTcpServerPermeateClientVisitorFilter(internalNetworkPenetrationRealClient, channelFlowAdapter);
-            return new NettyServerPermeateClientVisitorSocket(nettyServerPermeateClientVisitorFilter, clientId, visitorPort);
+            return new NettyTcpServerPermeateClientVisitorSocket(nettyTcpServerPermeateClientVisitorFilter, clientId, visitorPort);
         }
 
 

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateServerConnectRealSocket.java

@@ -8,7 +8,7 @@ import io.netty.channel.socket.nio.NioSocketChannel;
 import lombok.extern.slf4j.Slf4j;
 import org.framework.lazy.cloud.network.heartbeat.common.InternalNetworkServerPermeateServerRealServer;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerPermeateServerRealFilter;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerPermeateServerRealFilter;
 
 import java.util.concurrent.TimeUnit;
 
@@ -16,7 +16,7 @@ import java.util.concurrent.TimeUnit;
  * 服务端渗透服务端 连接真实通道
  */
 @Slf4j
-public class NettyServerPermeateServerConnectRealSocket {
+public class NettyTcpServerPermeateServerConnectRealSocket {
     private static final EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
 
     /**
@@ -50,7 +50,7 @@ public class NettyServerPermeateServerConnectRealSocket {
 //                    .option(ChannelOption.SO_BACKLOG, 128)//务端接受连接的队列长度 默认128
 //                    .option(ChannelOption.RCVBUF_ALLOCATOR, new NettyRecvByteBufAllocator(1024 * 1024))//用于Channel分配接受Buffer的分配器 默认AdaptiveRecvByteBufAllocator.DEFAULT
                     .option(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2))
-                    .handler(new NettyServerPermeateServerRealFilter(internalNetworkServerPermeateServerRealServer))
+                    .handler(new NettyTcpServerPermeateServerRealFilter(internalNetworkServerPermeateServerRealServer))
 
             ;
 

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/netty/tcp/socket/NettyTcpServerPermeateServerConnectVisitorSocket.java

@@ -11,7 +11,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.InternalNetworkServerPe
 import org.framework.lazy.cloud.network.heartbeat.common.NettyServerPermeateServerVisitorContext;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyVisitorPortContext;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyServerPermeateServerVisitorFilter;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.filter.NettyTcpServerPermeateServerVisitorFilter;
 
 import java.io.IOException;
 
@@ -19,18 +19,18 @@ import java.io.IOException;
  * 服务端渗透服务端 访客端口
  */
 @Slf4j
-public class NettyServerPermeateServerConnectVisitorSocket {
+public class NettyTcpServerPermeateServerConnectVisitorSocket {
     private final EventLoopGroup bossGroup = new NioEventLoopGroup();
     private final EventLoopGroup workerGroup = new NioEventLoopGroup();
-    private final NettyServerPermeateServerVisitorFilter nettyServerPermeateServerVisitorFilter;
+    private final NettyTcpServerPermeateServerVisitorFilter nettyTcpServerPermeateServerVisitorFilter;
 
     @Getter
     private final int visitorPort;
 
 
-    public NettyServerPermeateServerConnectVisitorSocket(NettyServerPermeateServerVisitorFilter nettyServerPermeateServerVisitorFilter,
+    public NettyTcpServerPermeateServerConnectVisitorSocket(NettyTcpServerPermeateServerVisitorFilter nettyTcpServerPermeateServerVisitorFilter,
-                                                         int visitorPort) {
+                                                            int visitorPort) {
-        this.nettyServerPermeateServerVisitorFilter = nettyServerPermeateServerVisitorFilter;
+        this.nettyTcpServerPermeateServerVisitorFilter = nettyTcpServerPermeateServerVisitorFilter;
         this.visitorPort = visitorPort;
     }
 
@@ -42,8 +42,8 @@ public class NettyServerPermeateServerConnectVisitorSocket {
      */
     public void start() throws Exception {
 
-        NettyServerPermeateServerConnectVisitorSocket nettyServerPermeateServerConnectVisitorSocket = NettyServerPermeateServerVisitorContext.getServerPermeateServerVisitorSocket(visitorPort);
+        NettyTcpServerPermeateServerConnectVisitorSocket nettyTcpServerPermeateServerConnectVisitorSocket = NettyServerPermeateServerVisitorContext.getServerPermeateServerVisitorSocket(visitorPort);
-        if (nettyServerPermeateServerConnectVisitorSocket == null) {
+        if (nettyTcpServerPermeateServerConnectVisitorSocket == null) {
             ServerBootstrap bootstrap = new ServerBootstrap();
             bootstrap
                     .group(bossGroup, workerGroup)
@@ -63,7 +63,7 @@ public class NettyServerPermeateServerConnectVisitorSocket {
                     .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(1024 * 1024, 1024 * 1024 * 2))
 
 
-                    .childHandler(nettyServerPermeateServerVisitorFilter);
+                    .childHandler(nettyTcpServerPermeateServerVisitorFilter);
             ChannelFuture sync = bootstrap.bind(visitorPort).sync();
             sync.addListener((ChannelFutureListener) future -> {
                 if (future.isSuccess()) {
@@ -189,7 +189,7 @@ public class NettyServerPermeateServerConnectVisitorSocket {
         }
 
 
-        public NettyServerPermeateServerConnectVisitorSocket build() {
+        public NettyTcpServerPermeateServerConnectVisitorSocket build() {
 
             if (clientTargetIp == null) {
                 throw new IllegalArgumentException("clientTargetIp must not null");
@@ -208,8 +208,8 @@ public class NettyServerPermeateServerConnectVisitorSocket {
                     .isSsl(isSsl)
                     .build();
 
-            NettyServerPermeateServerVisitorFilter nettyServerPermeateServerVisitorFilter = new NettyServerPermeateServerVisitorFilter(internalNetworkServerPermeateServerRealServer, channelFlowAdapter);
+            NettyTcpServerPermeateServerVisitorFilter nettyTcpServerPermeateServerVisitorFilter = new NettyTcpServerPermeateServerVisitorFilter(internalNetworkServerPermeateServerRealServer, channelFlowAdapter);
-            return new NettyServerPermeateServerConnectVisitorSocket(nettyServerPermeateServerVisitorFilter, permeateVisitorPort);
+            return new NettyTcpServerPermeateServerConnectVisitorSocket(nettyTcpServerPermeateServerVisitorFilter, permeateVisitorPort);
         }
 
 

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyInternalNetworkServerPermeateClientMappingApplicationImpl.java

@@ -4,7 +4,7 @@ import jakarta.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyClientVisitorContext;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyServerPermeateClientVisitorSocket;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyTcpServerPermeateClientVisitorSocket;
 import org.framework.lazy.cloud.network.heartbeat.server.properties.ServerNodeProperties;
 import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.LazyInternalNetworkServerPermeateClientMappingApplication;
 import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.assembler.InternalNetworkPenetrationMappingDTOAssembler;
@@ -156,14 +156,14 @@ public class LazyInternalNetworkServerPermeateClientMappingApplicationImpl imple
      */
     private void changeCloseSocket(String clientId, Integer visitorPort) {
         // 删除 客户端映射
-        List<NettyServerPermeateClientVisitorSocket> nettyServerPermeateClientVisitorSocketList = NettyClientVisitorContext.getVisitorSockets(clientId);
+        List<NettyTcpServerPermeateClientVisitorSocket> nettyTcpServerPermeateClientVisitorSocketList = NettyClientVisitorContext.getVisitorSockets(clientId);
-        if (!ObjectUtils.isEmpty(nettyServerPermeateClientVisitorSocketList)) {
+        if (!ObjectUtils.isEmpty(nettyTcpServerPermeateClientVisitorSocketList)) {
-            nettyServerPermeateClientVisitorSocketList = nettyServerPermeateClientVisitorSocketList.stream()
+            nettyTcpServerPermeateClientVisitorSocketList = nettyTcpServerPermeateClientVisitorSocketList.stream()
-                    .filter(nettyServerPermeateClientVisitorSocket -> nettyServerPermeateClientVisitorSocket.getVisitorPort() == visitorPort).toList();
+                    .filter(nettyTcpServerPermeateClientVisitorSocket -> nettyTcpServerPermeateClientVisitorSocket.getVisitorPort() == visitorPort).toList();
-            if (!ObjectUtils.isEmpty(nettyServerPermeateClientVisitorSocketList)) {
+            if (!ObjectUtils.isEmpty(nettyTcpServerPermeateClientVisitorSocketList)) {
                 // 关闭端口
-                for (NettyServerPermeateClientVisitorSocket nettyServerPermeateClientVisitorSocket : nettyServerPermeateClientVisitorSocketList) {
+                for (NettyTcpServerPermeateClientVisitorSocket nettyTcpServerPermeateClientVisitorSocket : nettyTcpServerPermeateClientVisitorSocketList) {
-                        nettyServerPermeateClientVisitorSocket.close();
+                        nettyTcpServerPermeateClientVisitorSocket.close();
                 }
                 // 关闭通道 socket
 
@@ -282,7 +282,7 @@ public class LazyInternalNetworkServerPermeateClientMappingApplicationImpl imple
 
         try {
             // 更新 客户端映射
-            NettyServerPermeateClientVisitorSocket nettyServerPermeateClientVisitorSocket = NettyServerPermeateClientVisitorSocket.NettyVisitorSocketBuilder
+            NettyTcpServerPermeateClientVisitorSocket nettyTcpServerPermeateClientVisitorSocket = NettyTcpServerPermeateClientVisitorSocket.NettyVisitorSocketBuilder
                     .builder()
                     .builderClientId(clientId)
                     .builderClientTargetIp(clientTargetIp)
@@ -290,7 +290,7 @@ public class LazyInternalNetworkServerPermeateClientMappingApplicationImpl imple
                     .builderVisitorPort(visitorPort)
                     .builderChannelFlowAdapter(channelFlowAdapter)
                     .build();
-            nettyServerPermeateClientVisitorSocket.start();
+            nettyTcpServerPermeateClientVisitorSocket.start();
         } catch (Exception e) {
             e.printStackTrace();
             log.error("客户端:{},网络端口:{},开放失败", clientId, visitorPort);

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyInternalNetworkServerPermeateServerMappingApplicationImpl.java

@@ -4,7 +4,7 @@ import jakarta.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyServerPermeateServerVisitorContext;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelFlowAdapter;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyServerPermeateServerConnectVisitorSocket;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyTcpServerPermeateServerConnectVisitorSocket;
 import org.framework.lazy.cloud.network.heartbeat.server.properties.ServerNodeProperties;
 import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.LazyInternalNetworkServerPermeateServerMappingApplication;
 import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.assembler.LazyInternalNetworkServerPermeateServerMappingDTOAssembler;
@@ -222,11 +222,11 @@ public class LazyInternalNetworkServerPermeateServerMappingApplicationImpl imple
      */
     private void closeServerPermeateServerSocket(Integer visitorPort) {
         // 删除 客户端映射
-        NettyServerPermeateServerConnectVisitorSocket nettyServerPermeateServerConnectVisitorSocket = NettyServerPermeateServerVisitorContext.getServerPermeateServerVisitorSocket(visitorPort);
+        NettyTcpServerPermeateServerConnectVisitorSocket nettyTcpServerPermeateServerConnectVisitorSocket = NettyServerPermeateServerVisitorContext.getServerPermeateServerVisitorSocket(visitorPort);
-        if (!ObjectUtils.isEmpty(nettyServerPermeateServerConnectVisitorSocket)) {
+        if (!ObjectUtils.isEmpty(nettyTcpServerPermeateServerConnectVisitorSocket)) {
             // 关闭端口
             try {
-                nettyServerPermeateServerConnectVisitorSocket.close();
+                nettyTcpServerPermeateServerConnectVisitorSocket.close();
                 NettyServerPermeateServerVisitorContext.removeServerPermeateServerVisitorSockets(visitorPort);
             } catch (IOException | InterruptedException e) {
                 throw new RuntimeException(e);
@@ -243,7 +243,7 @@ public class LazyInternalNetworkServerPermeateServerMappingApplicationImpl imple
      */
     private void createServerPermeateServerVisitor(String permeateTargetIp, Integer permeateTargetPort, Integer visitorPort, Boolean isSsl) {
         // 更新 客户端映射
-        NettyServerPermeateServerConnectVisitorSocket nettyServerPermeateServerConnectVisitorSocket = NettyServerPermeateServerConnectVisitorSocket.NettyPermeateVisitorSocketBuilder
+        NettyTcpServerPermeateServerConnectVisitorSocket nettyTcpServerPermeateServerConnectVisitorSocket = NettyTcpServerPermeateServerConnectVisitorSocket.NettyPermeateVisitorSocketBuilder
                 .builder()
                 .builderClientTargetIp(permeateTargetIp)
                 .builderClientTargetPort(permeateTargetPort)
@@ -252,7 +252,7 @@ public class LazyInternalNetworkServerPermeateServerMappingApplicationImpl imple
                 .builderChannelFlowAdapter(channelFlowAdapter)
                 .build();
         try {
-            nettyServerPermeateServerConnectVisitorSocket.start();
+            nettyTcpServerPermeateServerConnectVisitorSocket.start();
         } catch (Exception e) {
             log.error("内网渗透,网络端口:{},开放失败", visitorPort);
             throw new RuntimeException(e);

wu-lazy-cloud-heartbeat-server/src/main/java/org/framework/lazy/cloud/network/heartbeat/server/standalone/application/impl/LazyNettyClientStateApplicationImpl.java

@@ -8,7 +8,7 @@ import org.framework.lazy.cloud.network.heartbeat.common.ChannelContext;
 import org.framework.lazy.cloud.network.heartbeat.common.MessageType;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyClientVisitorContext;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyServerPermeateClientVisitorSocket;
+import org.framework.lazy.cloud.network.heartbeat.server.netty.tcp.socket.NettyTcpServerPermeateClientVisitorSocket;
 import org.framework.lazy.cloud.network.heartbeat.server.properties.ServerNodeProperties;
 import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.LazyNettyClientStateApplication;
 import org.framework.lazy.cloud.network.heartbeat.server.standalone.application.assembler.NettyClientStateDTOAssembler;
@@ -207,10 +207,10 @@ public class LazyNettyClientStateApplicationImpl implements LazyNettyClientState
         // 心跳关闭
         ChannelContext.clear(clientId);
         // 关闭访客
-        List<NettyServerPermeateClientVisitorSocket> nettyServerPermeateClientVisitorSocketList = NettyClientVisitorContext.getVisitorSockets(clientId);
+        List<NettyTcpServerPermeateClientVisitorSocket> nettyTcpServerPermeateClientVisitorSocketList = NettyClientVisitorContext.getVisitorSockets(clientId);
-        if (!ObjectUtils.isEmpty(nettyServerPermeateClientVisitorSocketList)) {
+        if (!ObjectUtils.isEmpty(nettyTcpServerPermeateClientVisitorSocketList)) {
-            for (NettyServerPermeateClientVisitorSocket nettyServerPermeateClientVisitorSocket : nettyServerPermeateClientVisitorSocketList) {
+            for (NettyTcpServerPermeateClientVisitorSocket nettyTcpServerPermeateClientVisitorSocket : nettyTcpServerPermeateClientVisitorSocketList) {
-                nettyServerPermeateClientVisitorSocket.close();
+                nettyTcpServerPermeateClientVisitorSocket.close();
             }
         }
         NettyClientVisitorContext.removeVisitorSockets(clientId);