【fix】1.2.9-JDK17

ClientPermeateClient.md

@@ -7,19 +7,19 @@
 
 #### 操作步骤：拥有公网ip的服务器开发6001（web）、7001端口（tcp），然后执行命令启动服务端
 ```shell
-docker run  -d -it -p 6001:6001 -p 7001:7001 -e spring.profiles.active=prod -e MAIN_DB_HOST=localhost:3306 -e MAIN_DB_PASSWORD=root  -e MAIN_DB_PASSWORD=root --name wu-lazy-cloud-heartbeat-server-start registry.cn-hangzhou.aliyuncs.com/wu-lazy/wu-lazy-cloud-heartbeat-server-start:1.3.1-JDK24-SNAPSHOT
+docker run  -d -it -p 6001:6001 -p 7001:7001 -e spring.profiles.active=prod -e MAIN_DB_HOST=localhost:3306 -e MAIN_DB_PASSWORD=root  -e MAIN_DB_PASSWORD=root --name wu-lazy-cloud-heartbeat-server-start registry.cn-hangzhou.aliyuncs.com/wu-lazy/wu-lazy-cloud-heartbeat-server-start:1.2.9-JDK17-SNAPSHOT
 ```
 
 #### 操作步骤：杭州本地机房所在网络服务器启动客户端、你老家所在网络中启动客户端，命令如下
 ```shell
-docker run -d -it --privileged --name hangzhou-client --restart=always -e spring.lazy.netty.client.inet-host=公网IP -e spring.lazy.netty.client.inet-port=7001 -e spring.lazy.netty.client.client-id="hangzhou-jifang" registry.cn-hangzhou.aliyuncs.com/wu-lazy/wu-lazy-cloud-heartbeat-client-start:1.3.1-JDK24-SNAPSHOT
+docker run -d -it --privileged --name hangzhou-client --restart=always -e spring.lazy.netty.client.inet-host=公网IP -e spring.lazy.netty.client.inet-port=7001 -e spring.lazy.netty.client.client-id="hangzhou-jifang" registry.cn-hangzhou.aliyuncs.com/wu-lazy/wu-lazy-cloud-heartbeat-client-start:1.2.9-JDK17-SNAPSHOT
 ```
 ```shell
-docker run -d -it --privileged --name my-home-client --restart=always -e spring.lazy.netty.client.inet-host=公网IP -e spring.lazy.netty.client.inet-port=7001 -e spring.lazy.netty.client.client-id="my-home" registry.cn-hangzhou.aliyuncs.com/wu-lazy/wu-lazy-cloud-heartbeat-client-start:1.3.1-JDK24-SNAPSHOT
+docker run -d -it --privileged --name my-home-client --restart=always -e spring.lazy.netty.client.inet-host=公网IP -e spring.lazy.netty.client.inet-port=7001 -e spring.lazy.netty.client.client-id="my-home" registry.cn-hangzhou.aliyuncs.com/wu-lazy/wu-lazy-cloud-heartbeat-client-start:1.2.9-JDK17-SNAPSHOT
 ```
 #### 操作步骤：配置端口
 ![client_permeate_port_pool.png](client_permeate_port_pool.png)
-#### 操作步骤：打开页面配置菜单看到如下界面（源客户端ID：你老家网络中的电脑，目标客户端ID）
+#### 操作步骤：打开页面配置菜单看到如下界面（from客户端ID：你老家网络中的电脑，to客户端ID）
 ![client_permeate_client_mapping.png](client_permeate_client_mapping.png)
 
 #### 连接使用：在你老家使用my-home这个客户端所在机器上的ip+13306 即可访问杭州机房内的数据库的服务3306

CloudClientInternalNetworkPenetration.README.md

@@ -2,8 +2,8 @@
 
 #### 模块说明
 
-| 模块                                                               | 所属层级 | 描述                     | 端口                                                             |
-|------------------------------------------------------------------|------|------------------------|----------------------------------------------------------------|
+| 模块                                                                                 | 所属层级 | 描述                     | 端口                                                             |
+|------------------------------------------------------------------------------------|------|------------------------|----------------------------------------------------------------|
 | [wu-lazy-cloud-heartbeat-common](wu-lazy-cloud-heartbeat-common) | 基础模块 | 基于Netty数据解码、编码、通道处理器声明 | 无                                                              |
 | [wu-lazy-cloud-heartbeat-server](wu-lazy-cloud-heartbeat-server) | 启动模块 | 内网穿透服务端                | http端口：6001、tcp端口:7001  (默认tcp端口=http端口+1000 如：6001+1000=7001) |
 | [wu-lazy-cloud-heartbeat-client](wu-lazy-cloud-heartbeat-client) | 启动模块 | 内网穿透客户端                | 6004                                                           |

LazyDNS.puml

@@ -1,61 +0,0 @@
-
-
-@startuml
-
-title 动态DNS
-
-actor 访客 as User
-
-package "服务端（公网）" as dns_server_{
-     component [服务端私有网络A]{
-         [mysql:(172.1.1.4:3306)] as dns_server_remote_local_
-         [clickhouse:(172.1.1.5:3306)]
-     }
-    component [服务端私有网络B]{
-      [mysql:(172.1.2.4:3306)]
-      [clickhouse:(172.1.2.5:3306)]
-    }
-
-}
-
-package "客户端（私有网络）" as dns_remote_local_{
-
-     component [客户端私有网络A]{
-         [mysql:(162.1.1.4:3306)] as dns_client_remote_local_
-         [clickhouse:(162.1.1.5:3306)]
-     }
-    component [客户端私有网络B]{
-      [mysql:(162.1.2.4:3306)]
-      [clickhouse:(162.1.2.5:3306)]
-    }
-}
-
-
-package "客户端（用户本地）" as dns_local_ {
-
-}
-
-
-
-note "用户本地网络" as local_net_
-note "服务端网络" as server_net_
-note "客户端私有网络" as remote_net_
-
-'(User) .... local_condition_
-'local_condition_ ... (target)
-
-[User] ...right...> dns_local_: DNS连接到本地
-dns_local_ ...right...> local_net_: 访问本地网络（本地DNS）
-dns_local_ ...up...> dns_server_remote_local_: 远程DNS解析
-
-dns_server_ ...up...> server_net_: server本地的网络
-dns_server_ ...down...> dns_remote_local_: 访问的地址在远程的客户端中
-dns_remote_local_ ...down...> dns_client_remote_local_: 远程客户端所在的私有网络
-dns_remote_local_ ...down...> remote_net_: 远程客户端中的其他网络
-
-
-
-
-
-@enduml
-

Proxy.md

@@ -1,33 +0,0 @@
-### 使用手册
-#### Mac 使用方式
-##### 获取socks或者http代理服务器信息
-    如：ip：127.0.0.1 port：9001（socks）、8001（http）
-##### 使用Wi-Fi代理
-    注意如下方式只能代理浏览器请求，无法代理其他应用请求
-![mac_http_proxy.png](mac_http_proxy.png)
-![mac_socks_proxy.png](mac_socks_proxy.png)
-
-##### 使用第三方软件全局代理[Proxifier3.8.0.dmg](Proxifier3.8.0.dmg)
-    注册码
-    # Proxifier Mac
-    cracked@macked.app
-    8TB85-UWT64-AKK2R-XGBDY-F2UP5
-    # Proxifier Standard Edition
-    cracked@macked.app
-    4JB8X-9YMEZ-BD332-PPNN3-46P48
-    # Proxifier Portable Edition
-    cracked@macked.app
-    FXBZZ-U2FPK-G5KW9-KAANW-TLGPL
-- Proxifier配置
-![Proxies_Config_1.png](Proxies_Config_1.png)
-- 配置socks服务器地址
-![Proxies_Config_2.png](Proxies_Config_2.png)
-![Proxies_Config_3.png](Proxies_Config_3.png)
-- 配置代理路由
-![Proxies_Config_4.png](Proxies_Config_4.png)
-- 展示效果
-![proxy_inner_net_ui.png](proxy_inner_net_ui.png)
-
-#### Windows 使用方式
-##### 使用Wi-Fi代理
-![windows_wifi_proxy.png](windows_wifi_proxy.png)

README.md

@@ -14,9 +14,6 @@
     <a target="_blank" href="https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html">
 		<img src="https://img.shields.io/badge/JDK-17-green.svg" alt="jdk-17" />
 	</a>
-    <a target="_blank" href="https://www.oracle.com/java/technologies/javase/jdk24-archive-downloads.html">
-		<img src="https://img.shields.io/badge/JDK-24-green.svg" alt="jdk-24" />
-	</a>
     <br />
         <img src="https://img.shields.io/badge/SpringBoot-v3.x-blue">
     <br />
@@ -36,7 +33,7 @@
 
 wu-lazy-cloud-network
 是一款基于（[wu-framework-parent](https://gitee.com/wujiawei1207537021/wu-framework-parent)）孵化出的项目，内部使用Lazy
-ORM操作数据库，使用环境JDK24 Spring Boot 3.5.0。的网络穿透、渗透工具支持Tcp、Http、Socks
+ORM操作数据库，使用环境JDK17 Spring Boot 3.0.2。
 主要功能：
 - 服务端渗透客户端（网络穿透），对于没有公网IP的服务进行公网IP映射
 - ![NetworkPermeateServerPermeateClient.png](NetworkPermeateServerPermeateClient.png)
@@ -46,22 +43,10 @@ ORM操作数据库，使用环境JDK24 Spring Boot 3.5.0。的网络穿透、渗
 - ![NetworkPermeateClientPermeateServer.png](NetworkPermeateClientPermeateServer.png)
 - 客户端渗透客户端----本地端口映射到另一个局域网端口
 - ![NetworkPermeateClientPermeateClient.png](NetworkPermeateClientPermeateClient.png)
-- 客户端代理服务端、客户端代理客户端、服务端代理服务端、服务端代理客户端（VPN）----异地组网搭建代理
-- ![wlcn-proxy1.0-.png](wlcn-proxy1.0-.png)
+
 
 [UI](https://gitee.com/wujiawei1207537021/wu-lazy-cloud-network-server-ui)
 
-### 内网穿透
-
-| 模块                                   | 所属层级 | 描述                           | 快照版本                                                                                                                                                                                                                                                                                                           | 发布版本                                                                                                                                                                                                                                                         |
-|--------------------------------------|------|------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| wu-lazy-cloud-heartbeat-common       | 组件   | 内网穿透公共模块（声明接口、枚举、常量、适配器、解析器） | <a target="_blank" href="https://search.maven.org/search?q=wu-lazy-cloud-heartbeat-common%20wu-bionic-parent"><img src="https://img.shields.io/nexus/s/top.wu2020/wu-bionic-parent?server=https%3A%2F%2Foss.sonatype.org&style=flat&logo=log" alt="Maven" /></a>                                               | <a target="_blank" href="https://search.maven.org/search?q=wu-lazy-cloud-heartbeat-common%20wu-lazy-cloud-heartbeat-common"><img src="https://img.shields.io/maven-central/v/top.wu2020/wu-lazy-cloud-heartbeat-common" alt="Maven" /></a>                   |
-| wu-lazy-cloud-heartbeat-client       | 组件   | 客户端（支持二次开发）                  | <a target="_blank" href="https://search.maven.org/search?q=wu-lazy-cloud-heartbeat-client%20wu-lazy-cloud-heartbeat-client"><img src="https://img.shields.io/nexus/s/top.wu2020/wu-lazy-cloud-heartbeat-client?server=https%3A%2F%2Foss.sonatype.org&style=flat&logo=log" alt="Maven" /></a>                   | <a target="_blank" href="https://search.maven.org/search?q=wu-lazy-cloud-heartbeat-client%20wu-lazy-cloud-heartbeat-client"><img src="https://img.shields.io/maven-central/v/top.wu2020/wu-lazy-cloud-heartbeat-client" alt="Maven" /></a>                   |
-| wu-lazy-cloud-heartbeat-server       | 组件   | 服务端（支持二次开发）                  | <a target="_blank" href="https://search.maven.org/search?q=wu-lazy-cloud-heartbeat-server%20wu-lazy-cloud-heartbeat-server"><img src="https://img.shields.io/nexus/s/top.wu2020/wu-lazy-cloud-heartbeat-server?server=https%3A%2F%2Foss.sonatype.org&style=flat&logo=log" alt="Maven" /></a>                   | <a target="_blank" href="https://search.maven.org/search?q=wu-lazy-cloud-heartbeat-server%20wu-lazy-cloud-heartbeat-server"><img src="https://img.shields.io/maven-central/v/top.wu2020/wu-lazy-cloud-heartbeat-server" alt="Maven" /></a>                   |
-| wu-lazy-cloud-ui                     | ui   | 服务端页面                        |                                                                                                                                                                                                                                                                                                                |                                                                                                                                                                                                                                                              |
-| wu-lazy-cloud-heartbeat-client-start | 客户端  | 客户端                          | <a target="_blank" href="https://search.maven.org/search?q=wu-lazy-cloud-heartbeat-client-start%20wu-lazy-cloud-heartbeat-client-start"><img src="https://img.shields.io/nexus/s/top.wu2020/wu-lazy-cloud-heartbeat-client-start?server=https%3A%2F%2Foss.sonatype.org&style=flat&logo=log" alt="Maven" /></a> | <a target="_blank" href="https://search.maven.org/search?q=wu-lazy-cloud-heartbeat-client-start%20wu-lazy-cloud-heartbeat-client-start"><img src="https://img.shields.io/maven-central/v/top.wu2020/wu-lazy-cloud-heartbeat-client-start" alt="Maven" /></a> |
-| wu-lazy-cloud-heartbeat-server-start | 服务端  | 服务端                          | <a target="_blank" href="https://search.maven.org/search?q=wu-lazy-cloud-heartbeat-server-start%20wu-lazy-cloud-heartbeat-server-start"><img src="https://img.shields.io/nexus/s/top.wu2020/wu-lazy-cloud-heartbeat-server-start?server=https%3A%2F%2Foss.sonatype.org&style=flat&logo=log" alt="Maven" /></a> | <a target="_blank" href="https://search.maven.org/search?q=wu-lazy-cloud-heartbeat-server-start%20wu-lazy-cloud-heartbeat-server-start"><img src="https://img.shields.io/maven-central/v/top.wu2020/wu-lazy-cloud-heartbeat-server-start" alt="Maven" /></a> |
-
 #### 项目地址
 
 [Gitee](https://gitee.com/wujiawei1207537021/wu-lazy-cloud-network)
@@ -72,6 +57,191 @@ ORM操作数据库，使用环境JDK24 Spring Boot 3.5.0。的网络穿透、渗
 
 ![architecture.png](architecture.png)
 
+#### 实现原理
+
+##### 服务端创建socket服务端绑定本地端口（用于客户端连接）
+
+```java
+package org.framework.lazy.cloud.network.heartbeat.server.netty.socket;
+
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelOption;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import filter.netty.org.framework.lazy.cloud.network.heartbeat.server.NettyServerFilter;
+
+public class NettyOnCloudNettyServerSocket {
+    private final EventLoopGroup bossGroup = new NioEventLoopGroup();
+    private final EventLoopGroup workerGroup = new NioEventLoopGroup();
+    private final NettyServerFilter nettyServerFilter;// 通道业务处理
+    private ChannelFuture channelFuture;
+
+    public NettyOnCloudNettyServerSocket(NettyServerFilter nettyServerFilter) {
+        this.nettyServerFilter = nettyServerFilter;
+    }
+
+    /**
+     * 启动服务端
+     *
+     * @throws Exception
+     */
+    public void startServer(int serverPort) throws Exception {
+        try {
+
+            ServerBootstrap b = new ServerBootstrap();
+            b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
+                    // 给服务端channel设置属性
+                    .option(ChannelOption.SO_BACKLOG, 128)
+
+                    .childOption(ChannelOption.SO_KEEPALIVE, true)
+                    .childHandler(nettyServerFilter)
+            ;
+            channelFuture = b.bind(serverPort).sync();
+
+            channelFuture.addListener((ChannelFutureListener) channelFuture -> {
+                // 服务器已启动
+            });
+            channelFuture.channel().closeFuture().sync();
+        } finally {
+            shutdown();
+            // 服务器已关闭
+        }
+    }
+
+    public void shutdown() {
+        if (channelFuture != null) {
+            channelFuture.channel().close().syncUninterruptibly();
+        }
+        if ((bossGroup != null) && (!bossGroup.isShutdown())) {
+            bossGroup.shutdownGracefully();
+        }
+        if ((workerGroup != null) && (!workerGroup.isShutdown())) {
+            workerGroup.shutdownGracefully();
+        }
+    }
+}
+```
+
+##### 客户端通过class NettyClientSocket 连接服务端
+
+```java
+package org.framework.lazy.cloud.network.heartbeat.client.netty.socket;
+
+
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.client.application.ClientChangeEvent;
+import filter.netty.org.framework.lazy.cloud.heartbeat.client.NettyClientFilter;
+import org.framework.lazy.cloud.network.heartbeat.common.MessageType;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import adapter.org.framework.lazy.cloud.network.heartbeat.common.ChannelTypeAdapter;
+import advanced.org.framework.lazy.cloud.network.heartbeat.common.HandleChannelTypeAdvanced;
+import utils.org.framework.lazy.cloud.network.heartbeat.common.ChannelAttributeKeyUtils;
+
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 客户端连接服务端
+ */
+@Slf4j
+public class NettyClientSocket {
+    private static final EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
+    /**
+     * 服务端host
+     */
+    private final String inetHost;
+    /**
+     * 服务端端口
+     */
+    private final int inetPort;
+    /**
+     * 当前客户端id
+     */
+    @Getter
+    private final String clientId;
+    /**
+     * nacos配置信息处理应用
+     */
+    @Getter
+    private final ClientNettyConfigApplication clientChangeEvent;
+    private final List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList; // 处理服务端发送过来的数据类型
+
+    public NettyClientSocket(String inetHost, int inetPort, String clientId, ClientNettyConfigApplication clientChangeEvent, List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList) {
+        this.inetHost = inetHost;
+        this.inetPort = inetPort;
+        this.clientId = clientId;
+        this.clientChangeEvent = clientChangeEvent;
+        this.handleChannelTypeAdvancedList = handleChannelTypeAdvancedList;
+    }
+
+    public void newConnect2Server() throws InterruptedException {
+        newConnect2Server(inetHost, inetPort, clientId, clientChangeEvent);
+    }
+
+    protected void newConnect2Server(String inetHost, int inetPort, String clientId, ClientNettyConfigApplication clientChangeEvent) throws InterruptedException {
+        Bootstrap bootstrap = new Bootstrap();
+        bootstrap.group(eventLoopGroup)
+                .channel(NioSocketChannel.class)
+                .handler(new NettyClientFilter(new ChannelTypeAdapter(handleChannelTypeAdvancedList), this))
+        ;
+
+        log.info("连接服务端IP:{},连接服务端端口:{}", inetHost, inetPort);
+        ChannelFuture future = bootstrap.connect(inetHost, inetPort);
+        Channel channel = future.channel();
+
+        log.info("使用的客户端ID:" + clientId);
+        future.addListener((ChannelFutureListener) futureListener -> {
+            if (futureListener.isSuccess()) {
+
+                log.info("连接服务端成功");
+                // 告诉服务端这条连接是client的连接
+                NettyProxyMsg nettyMsg = new NettyProxyMsg();
+                nettyMsg.setType(MessageType.TCP_REPORT_CLIENT_CONNECT_SUCCESS);
+                nettyMsg.setClientId(clientId);
+                nettyMsg.setData((clientId).getBytes());
+                ChannelAttributeKeyUtils.buildClientId(channel, clientId);
+                channel.writeAndFlush(nettyMsg);
+                // 在线
+                clientChangeEvent.clientOnLine(clientId);
+            } else {
+                log.info("每隔2s重连....");
+                // 离线
+                clientChangeEvent.clientOffLine(clientId);
+                futureListener.channel().eventLoop().schedule(() -> {
+                    try {
+                        newConnect2Server(inetHost, inetPort, clientId, clientChangeEvent);
+                    } catch (InterruptedException e) {
+                        e.printStackTrace();
+                    }
+                }, 2, TimeUnit.SECONDS);
+            }
+        });
+    }
+
+    /**
+     * 关闭连接
+     */
+
+    public void shutdown() {
+        if ((eventLoopGroup != null) && (!eventLoopGroup.isShutdown())) {
+            eventLoopGroup.shutdownGracefully();
+        }
+    }
+
+}
+```
 
 ##### 通过客户端与服务端建立的连接进行访客端口绑定
 
@@ -85,27 +255,26 @@ ORM操作数据库，使用环境JDK24 Spring Boot 3.5.0。的网络穿透、渗
     1.内网穿透
     2.服务端自主下发数据到客户端
     3.流量监控
-    4.网络代理（socks、http）
 
 ### 项目结构
 
 | 模块                                                                                                         | 版本                   | 描述                           |
 |------------------------------------------------------------------------------------------------------------|----------------------|------------------------------| 
-| [wu-lazy-cloud-heartbeat-common](wu-lazy-cloud-heartbeat-common)                                           | 1.3.1-JDK24-SNAPSHOT | 内网穿透公共模块（声明接口、枚举、常量、适配器、解析器） |
-| [wu-lazy-cloud-heartbeat-client](wu-lazy-cloud-heartbeat-client)                                           | 1.3.1-JDK24-SNAPSHOT | 客户端（支持二次开发）                  |
-| [wu-lazy-cloud-heartbeat-server](wu-lazy-cloud-heartbeat-server)                                           | 1.3.1-JDK24-SNAPSHOT | 服务端（支持二次开发）                  |
-| [wu-lazy-cloud-heartbeat-client-start](wu-lazy-cloud-heartbeat-start/wu-lazy-cloud-heartbeat-server-start) | 1.3.1-JDK24-SNAPSHOT | 客户端样例                        |
-| [wu-lazy-cloud-heartbeat-server-start](wu-lazy-cloud-heartbeat-start/wu-lazy-cloud-heartbeat-client-start) | 1.3.1-JDK24-SNAPSHOT | 服务端样例                        |
+| [wu-lazy-cloud-heartbeat-common](wu-lazy-cloud-heartbeat-common)                                           | 1.2.9-JDK17-SNAPSHOT | 内网穿透公共模块（声明接口、枚举、常量、适配器、解析器） |
+| [wu-lazy-cloud-heartbeat-client](wu-lazy-cloud-heartbeat-client)                                           | 1.2.9-JDK17-SNAPSHOT | 客户端（支持二次开发）                  |
+| [wu-lazy-cloud-heartbeat-server](wu-lazy-cloud-heartbeat-server)                                           | 1.2.9-JDK17-SNAPSHOT | 服务端（支持二次开发）                  |
+| [wu-lazy-cloud-heartbeat-client-start](wu-lazy-cloud-heartbeat-start/wu-lazy-cloud-heartbeat-server-start) | 1.2.9-JDK17-SNAPSHOT | 客户端样例                        |
+| [wu-lazy-cloud-heartbeat-server-start](wu-lazy-cloud-heartbeat-start/wu-lazy-cloud-heartbeat-client-start) | 1.2.9-JDK17-SNAPSHOT | 服务端样例                        |
 
 ### 使用技术
 
 | 框架                                                                                                                                                                          | 版本                   | 描述           |
 |-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------|--------------| 
 | spring-boot                                                                                                                                                                 | 3.0.7                | springboot框架 |
-| [wu-framework-web](https://gitee.com/wujiawei1207537021/wu-framework-parent/tree/master/wu-framework-web)                                                                   | 1.3.1-JDK24-SNAPSHOT | web容器        |
-| [Lazy -ORM](https://gitee.com/wujiawei1207537021/wu-framework-parent/tree/master/wu-inner-intergration/wu-database-parent)                                                  | 1.3.1-JDK24-SNAPSHOT | ORM          |
+| [wu-framework-web](https://gitee.com/wujiawei1207537021/wu-framework-parent/tree/master/wu-framework-web)                                                                   | 1.2.9-JDK17-SNAPSHOT | web容器        |
+| [Lazy -ORM](https://gitee.com/wujiawei1207537021/wu-framework-parent/tree/master/wu-inner-intergration/wu-database-parent)                                                  | 1.2.9-JDK17-SNAPSHOT | ORM          |
 | mysql-connector-j                                                                                                                                                           | 8.0.33               | mysql驱动      |
-| [wu-authorization-server-platform-starter](https://gitee.com/wujiawei1207537021/wu-framework-parent/tree/master/wu-smart-platform/wu-authorization-server-platform-starter) | 1.3.1-JDK24-SNAPSHOT | 用户授权体系       |
+| [wu-authorization-server-platform-starter](https://gitee.com/wujiawei1207537021/wu-framework-parent/tree/master/wu-smart-platform/wu-authorization-server-platform-starter) | 1.2.9-JDK17-SNAPSHOT | 用户授权体系       |
 
 ### 使用环境
 
@@ -114,16 +283,15 @@ ORM操作数据库，使用环境JDK24 Spring Boot 3.5.0。的网络穿透、渗
     JAVA >=13
     MAVEN
 
-### 启动[install.md](install.md)
+### 启动
 
     docker启动
         
-        docker run  -d -it -p 18080:18080 --name wu-lazy-cloud-heartbeat-server registry.cn-hangzhou.aliyuncs.com/wu-lazy/wu-lazy-cloud-heartbeat-server:1.3.1-JDK24-SNAPSHOT
+        docker run  -d -it -p 18080:18080 --name wu-lazy-cloud-heartbeat-server registry.cn-hangzhou.aliyuncs.com/wu-lazy/wu-lazy-cloud-heartbeat-server:1.2.9-JDK17-SNAPSHOT
         
         http://127.0.0.1:18080/swagger-ui/index.html
 
     源码启动
-### 代理工具使用[Proxy.md](Proxy.md)
 
 #### 页面操作
 
@@ -173,20 +341,4 @@ ORM操作数据库，使用环境JDK24 Spring Boot 3.5.0。的网络穿透、渗
 ![clientPerDayFlow.png](clientPerDayFlow.png)
 
 客户端近七天使用流量
-![clientPortPerDayFlow.png](clientPortPerDayFlow.png)
-
-## 路由
-- 客户端路由管理
-![client_route.png](client_route.png)
-- 客户端虚拟路由管理
-- 创建一个虚拟的不存在的IP，代理到指定的IP
-![client_virtual_route.png](client_virtual_route.png)
-
-- 服务端路由管理
-![server_route.png](server_route.png)
-- 服务端虚拟路由管理
-- 创建一个虚拟的不存在的IP，代理到指定的IP
-![server_virtual_route.png](server_virtual_route.png)
-- 
-- 代理流量管理
-![client_proxy_flow_manager.png](client_proxy_flow_manager.png)
+![clientPortPerDayFlow.png](clientPortPerDayFlow.png)

client-k8s.yaml

@@ -1,489 +0,0 @@
-
----
-kind: Deployment
-apiVersion: apps/v1
-metadata:
-  name: wu-lazy-cloud-heartbeat-local-client-start
-  namespace: default
-  labels:
-    k8s.kuboard.cn/layer: monitor
-    k8s.kuboard.cn/name: wu-lazy-cloud-heartbeat-local-client-start
-  annotations:
-    k8s.kuboard.cn/displayName: 内网穿透服务端(云下)
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      k8s.kuboard.cn/layer: monitor
-      k8s.kuboard.cn/name: wu-lazy-cloud-heartbeat-local-client-start
-  template:
-    metadata:
-      creationTimestamp: null
-      labels:
-        k8s.kuboard.cn/layer: monitor
-        k8s.kuboard.cn/name: wu-lazy-cloud-heartbeat-local-client-start
-      annotations:
-        kubectl.kubernetes.io/restartedAt: '2025-01-16T22:39:39+08:00'
-    spec:
-      containers:
-        - name: wu-lazy-cloud-heartbeat-local-client-start
-          image: >-
-            registry.cn-hangzhou.aliyuncs.com/wu-lazy/wu-lazy-cloud-heartbeat-client-start:1.3.1-JDK24-SNAPSHOT
-          env:
-            - name: spring.lazy.netty.client.inet-host
-              value: 124.222.48.62
-            - name: spring.lazy.netty.client.inet-port
-              value: '30560'
-            - name: spring.lazy.netty.client.client-id
-              value: tencent
-            - name: JAVA_OPTS
-              value: '-Xms32m -Xmx64m'
-            - name: logging1.level.root
-              value: DEBUG
-          resources: {}
-          terminationMessagePath: /dev/termination-log
-          terminationMessagePolicy: File
-          imagePullPolicy: Always
-          securityContext:
-            privileged: true
-            runAsUser: 0
-      restartPolicy: Always
-      terminationGracePeriodSeconds: 30
-      dnsPolicy: ClusterFirst
-      securityContext: {}
-      schedulerName: default-scheduler
-  strategy:
-    type: RollingUpdate
-    rollingUpdate:
-      maxUnavailable: 25%
-      maxSurge: 25%
-  revisionHistoryLimit: 10
-  progressDeadlineSeconds: 600
-
----
-kind: StatefulSet
-apiVersion: apps/v1
-metadata:
-  name: cloud-mysql
-  namespace: default
-  labels:
-    k8s.eip.work/layer: db
-    k8s.eip.work/name: cloud-mysql
-    k8s.kuboard.cn/name: cloud-mysql
-  annotations:
-    analysis.crane.io/replicas-recommendation: |
-      replicas: 1
-    analysis.crane.io/resource-recommendation: |
-      containers:
-      - containerName: mysql
-        target:
-          cpu: 229m
-          memory: 2070Mi
-    k8s.eip.work/displayName: 数据库
-    k8s.eip.work/ingress: 'false'
-    k8s.eip.work/service: NodePort
-    k8s.eip.work/workload: cloud-mysql
-    k8s.kuboard.cn/workload: cloud-mysql
-spec:
-  replicas: 0
-  selector:
-    matchLabels:
-      k8s.eip.work/layer: db
-      k8s.eip.work/name: cloud-mysql
-      k8s.kuboard.cn/name: cloud-mysql
-  template:
-    metadata:
-      creationTimestamp: null
-      labels:
-        k8s.eip.work/layer: db
-        k8s.eip.work/name: cloud-mysql
-        k8s.kuboard.cn/name: cloud-mysql
-      annotations:
-        kubectl.kubernetes.io/restartedAt: '2023-10-07T09:38:51+08:00'
-    spec:
-      volumes:
-        - name: mysql-cnf-map
-          configMap:
-            name: mysql-cnf
-            items:
-              - key: cnf
-                path: custom.cnf
-            defaultMode: 420
-        - name: tz
-          hostPath:
-            path: /usr/share/zoneinfo/Asia/Shanghai
-            type: File
-      containers:
-        - name: mysql
-          image: 'mysql:8.0.28'
-          env:
-            - name: MYSQL_ROOT_PASSWORD
-              value: wujiawei
-          resources:
-            limits:
-              cpu: 500m
-              memory: 256Mi
-            requests:
-              cpu: 500m
-              memory: 256Mi
-          volumeMounts:
-            - name: mysql-data
-              mountPath: /var/lib/mysql
-            - name: mysql-cnf-map
-              mountPath: /etc/mysql/conf.d/custom.cnf
-              subPath: custom.cnf
-            - name: tz
-              mountPath: /etc/localtime
-          terminationMessagePath: /dev/termination-log
-          terminationMessagePolicy: File
-          imagePullPolicy: IfNotPresent
-      restartPolicy: Always
-      terminationGracePeriodSeconds: 30
-      dnsPolicy: ClusterFirst
-      securityContext: {}
-      schedulerName: default-scheduler
-  volumeClaimTemplates:
-    - kind: PersistentVolumeClaim
-      apiVersion: v1
-      metadata:
-        name: mysql-data
-        creationTimestamp: null
-        annotations:
-          k8s.eip.work/pvcType: Dynamic
-      spec:
-        accessModes:
-          - ReadWriteMany
-        resources:
-          requests:
-            storage: 10Gi
-        storageClassName: nfs-storage
-        volumeMode: Filesystem
-      status:
-        phase: Pending
-  serviceName: cloud-mysql
-  podManagementPolicy: OrderedReady
-  updateStrategy:
-    type: RollingUpdate
-    rollingUpdate:
-      partition: 0
-  revisionHistoryLimit: 10
-  persistentVolumeClaimRetentionPolicy:
-    whenDeleted: Retain
-    whenScaled: Retain
-
----
-kind: Service
-apiVersion: v1
-metadata:
-  name: cloud-mysql
-  namespace: default
-  labels:
-    k8s.eip.work/layer: db
-    k8s.eip.work/name: cloud-mysql
-    k8s.kuboard.cn/name: cloud-mysql
-spec:
-  ports:
-    - name: zmac2s
-      protocol: TCP
-      port: 3306
-      targetPort: 3306
-      nodePort: 30512
-  selector:
-    k8s.eip.work/layer: db
-    k8s.eip.work/name: cloud-mysql
-  type: NodePort
-  sessionAffinity: None
-  externalTrafficPolicy: Cluster
-  ipFamilies:
-    - IPv4
-  ipFamilyPolicy: SingleStack
-  internalTrafficPolicy: Cluster
-
----
-kind: Service
-apiVersion: v1
-metadata:
-  name: wu-lazy-cloud-heartbeat-local-client-start
-  namespace: default
-  labels:
-    k8s.kuboard.cn/layer: monitor
-    k8s.kuboard.cn/name: wu-lazy-cloud-heartbeat-local-client-start
-spec:
-  ports:
-    - name: net
-      protocol: TCP
-      port: 6001
-      targetPort: 6001
-    - name: nas
-      protocol: TCP
-      port: 100
-      targetPort: 100
-    - name: kuboard
-      protocol: TCP
-      port: 101
-      targetPort: 101
-    - name: netty-client
-      protocol: TCP
-      port: 6004
-      targetPort: 6004
-    - name: nas-web-dav
-      protocol: TCP
-      port: 102
-      targetPort: 102
-    - name: rustdesk
-      protocol: TCP
-      port: 103
-      targetPort: 103
-    - name: nastool
-      protocol: TCP
-      port: 104
-      targetPort: 104
-    - name: jellyfin
-      protocol: TCP
-      port: 105
-      targetPort: 105
-    - name: qb
-      protocol: TCP
-      port: 106
-      targetPort: 106
-    - name: jackett
-      protocol: TCP
-      port: 107
-      targetPort: 107
-    - name: rustdesk-tcp
-      protocol: TCP
-      port: 108
-      targetPort: 108
-    - name: rustdesk-ip-tcp
-      protocol: TCP
-      port: 109
-      targetPort: 109
-    - name: rustdesk-ip-udp
-      protocol: UDP
-      port: 109
-      targetPort: 109
-    - name: nas-ssh
-      protocol: TCP
-      port: 110
-      targetPort: 110
-  selector:
-    k8s.kuboard.cn/layer: monitor
-    k8s.kuboard.cn/name: wu-lazy-cloud-heartbeat-local-client-start
-  type: ClusterIP
-  sessionAffinity: None
-  ipFamilies:
-    - IPv4
-  ipFamilyPolicy: SingleStack
-  internalTrafficPolicy: Cluster
-
----
-kind: Ingress
-apiVersion: networking.k8s.io/v1
-metadata:
-  name: wu-lazy-cloud-heartbeat-local-client-start
-  namespace: default
-  labels:
-    k8s.kuboard.cn/layer: monitor
-    k8s.kuboard.cn/name: wu-lazy-cloud-heartbeat-local-client-start
-spec:
-  ingressClassName: traefik
-  rules:
-    - host: net.wu-framework.cn
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: wu-lazy-cloud-heartbeat-local-client-start
-                port:
-                  number: 6001
-    - host: nas.wu-framework.cn
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: wu-lazy-cloud-heartbeat-local-client-start
-                port:
-                  number: 100
-    - host: kuboard.wu-framework.cn
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: wu-lazy-cloud-heartbeat-local-client-start
-                port:
-                  number: 101
-    - host: client.wu-framework.cn
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: wu-lazy-cloud-heartbeat-local-client-start
-                port:
-                  number: 6004
-    - host: nas-dav.wu-framework.cn
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: wu-lazy-cloud-heartbeat-local-client-start
-                port:
-                  number: 102
-    - host: rustdesk.wu-framework.cn
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: wu-lazy-cloud-heartbeat-local-client-start
-                port:
-                  number: 103
-    - host: nastool.wu-framework.cn
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: wu-lazy-cloud-heartbeat-local-client-start
-                port:
-                  number: 104
-    - host: jellyfin.wu-framework.cn
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: wu-lazy-cloud-heartbeat-local-client-start
-                port:
-                  number: 105
-    - host: qb.wu-framework.cn
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: wu-lazy-cloud-heartbeat-local-client-start
-                port:
-                  number: 106
-    - host: jackett.wu-framework.cn
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: wu-lazy-cloud-heartbeat-local-client-start
-                port:
-                  number: 107
-    - host: rustdesk-tcp.wu-framework.cn
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: wu-lazy-cloud-heartbeat-local-client-start
-                port:
-                  number: 108
-    - host: rustdesk-ip.wu-framework.cn
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: wu-lazy-cloud-heartbeat-local-client-start
-                port:
-                  number: 109
-    - host: nas-ssh.wu-framework.cn
-      http:
-        paths:
-          - path: /
-            pathType: Prefix
-            backend:
-              service:
-                name: wu-lazy-cloud-heartbeat-local-client-start
-                port:
-                  number: 110
-
----
-kind: ConfigMap
-apiVersion: v1
-metadata:
-  name: mysql-cnf
-  namespace: default
-data:
-  cnf: >-
-    [mysql]
-
-    no-auto-rehash
-
-    [mysqld]
-
-    skip-host-cache
-
-    skip-name-resolve
-
-    max_connections=100
-  
-    lower_case_table_names=0
-    
-    table_open_cache=64
-
-    default-time-zone='+08:00'
-
-    sql_mode='STRICT_TRANS_TABLES,NO_ZERO_IN_DATE,NO_ZERO_DATE,ERROR_FOR_DIVISION_BY_ZERO,NO_ENGINE_SUBSTITUTION'
-
-    log_timestamps='SYSTEM'
-
-    performance_schema_max_table_instances=400 #设置效果不明显
-    
-    performance_schema=off #效果明显
-    
-    table_definition_cache=400
-    
-    slow_query_log=ON
-
-    binlog_expire_logs_seconds = 2
-
-    innodb_flush_log_at_trx_commit=2
-
-    group_concat_max_len=512
-    
-    # 全局参数
-    
-    innodb_buffer_pool_size = 20M
-    
-    innodb_buffer_pool_chunk_size=20M #效果不明显
-    
-    key_buffer_size = 1M
-    
-    # 排序和连接参数
-    
-    sort_buffer_size = 256K
-    
-    join_buffer_size = 256K
-    
-    # 线程缓存参数
-    
-    thread_cache_size = 4
-    
-    # 日志参数
-    
-    innodb_log_file_size = 5M
-    
-    innodb_log_buffer_size = 1M
-

install.md

@@ -1,28 +0,0 @@
-#### docker环境安装wlcn
-##### 启动服务端
-- 6001端口 webui
-- 7001端口 tcp连接端口
-- 8001端口 http代理端口
-- 9001端口 socks代理端口
-- 1001端口 自定义需要代理到客户端端口
-- 打开浏览器访问界面 http://127.0.0.1:6001/netty-server-ui/index.html
-
-```shell
-
-docker run  -d -it -p 6001:6001  -p 7001:7001  -p 8001:8001  -p 9001:9001  --name wlcn-s registry.cn-hangzhou.aliyuncs.com/wu-lazy/wu-lazy-cloud-heartbeat-server:1.3.1-JDK24-SNAPSHOT
-
-```
-##### 启动客户端
-
-- 6004端口 webui
-- 8001端口 http代理端口
-- 9001端口 socks代理端口
-- 环境变量
-  - spring.lazy.netty.client.inet-host 服务端IP
-  - spring.lazy.netty.client.inet-port 服务端tcp端口
-  - spring.lazy.netty.client.client-id 客户端ID
-- 打开浏览器访问界面 http://127.0.0.1:6004/netty-client-local-ui/index.html
-
-```shell
-docker run -d -it --privileged -p 6004:6004 --name wlcn-c --restart=always -e spring.lazy.netty.client.inet-host=192.168.xx.xx -e spring.lazy.netty.client.inet-port=7001 -e spring.lazy.netty.client.client-id="wlcn-c" registry.cn-hangzhou.aliyuncs.com/wu-lazy/wu-lazy-cloud-heartbeat-client-start:1.3.1-JDK24-SNAPSHOT
-```

pom.xml

@@ -8,12 +8,12 @@
     <parent>
         <artifactId>wu-framework-parent</artifactId>
         <groupId>top.wu2020</groupId>
-        <version>1.3.1-JDK24-SNAPSHOT</version>
+        <version>1.2.9-JDK17</version>
     </parent>
 
     <artifactId>wu-lazy-cloud-network</artifactId>
     <packaging>pom</packaging>
-    <version>1.3.1-JDK24-SNAPSHOT</version>
+    <version>1.2.9-JDK17</version>
     <description>云上云下</description>
 
 
@@ -23,8 +23,6 @@
         <module>wu-lazy-cloud-heartbeat-server-cluster</module>
         <module>wu-lazy-cloud-heartbeat-client</module>
         <module>wu-lazy-cloud-heartbeat-common</module>
-        <module>wu-lazy-cloud-heartbeat-dns</module>
-        <module>wu-lazy-cloud-heartbeat-protocol-proxy</module>
 
         <!--    样例    -->
         <module>wu-lazy-cloud-heartbeat-start</module>
@@ -38,6 +36,7 @@
         <dependency>
             <groupId>org.projectlombok</groupId>
             <artifactId>lombok</artifactId>
+            <version>1.18.32</version>
         </dependency>
         <dependency>
             <groupId>org.projectlombok</groupId>
@@ -47,12 +46,12 @@
         <dependency>
             <groupId>org.mapstruct</groupId>
             <artifactId>mapstruct</artifactId>
-            <version>1.6.3</version>
+            <version>1.6.0.Beta1</version>
         </dependency>
         <dependency>
             <groupId>org.mapstruct</groupId>
             <artifactId>mapstruct-processor</artifactId>
-            <version>1.6.3</version>
+            <version>1.6.0.Beta1</version>
         </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
@@ -71,7 +70,7 @@
             <dependency>
                 <groupId>top.wu2020</groupId>
                 <artifactId>wu-framework-dependencies</artifactId>
-                <version>1.3.1-JDK24-SNAPSHOT</version>
+                <version>1.2.9-JDK17</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>

version.md

@@ -30,17 +30,4 @@
     [change] 修复通道关闭导致调度线程池submit异常问题
     [change] 添加记录客户端IP
     [change] 1.2.9为大版本，报文中添加数据无法向下兼容，建议服务端与客户端保持版本一致
-#### 1.3.1-JDK17-SNAPSHOT
-    [add] 新增http代理（客户端代理服务端、客户端代理客户杜安、服务端代理客户端、服务端代理服务端）
-    [add] 新增socks代理（客户端代理服务端、客户端代理客户杜安、服务端代理客户端、服务端代理服务端）
-    [add] 新增客户端路由管理、新增服务端路由管理
-    [add] 支持新增虚拟IP，代理到指定的IP
-    [add] 通过页面配置，代理支持控制端口代理控制
-#### 1.3.1-JDK17
-    [add] 新增代理流量监控
-    [add] docker仓库上架dockerhub，搜索https://hub.docker.com/search?q=wlcn
-
-#### 1.3.1-JDK24-SNAPSHOT
-    [add] 新增代理流量监控
-    [add] 升级使用jdk24、springboot 3.5.0
-#### 下一版本计划
+#### 下一版本计划https

wlcn-proxy1.0.puml

@@ -1,84 +0,0 @@
-
-
-@startuml
-
-title 网络代理
-
-
-
-package "服务端" as "服务端"{
-     node "12.16.5.xx"{
-        [12.16.5.1]
-        [wlcn_s_a] as "wlcn服务端"
-     }
-}
-
-
-
-
-package "杭州客户端"{
-    node "172.16.5.xx"{
-       [172.16.5.1]
-       [wlcn_c_a] as "wlcn客户端9001"
-       
-       
-       actor Navicat_c_a as "本地Navicat"
-       actor App_c_a as "本地App"
-       actor Chrome_c_a as "本地浏览器"
-       [socks_proxy_a] as "杭州本地用户socks代理软件"
-   
-       [socks_proxy_a]<--up--> [wlcn_c_a]:访客通过软件代理本地socks网络
-   
-       [Navicat_c_a]<..up..> [socks_proxy_a]:访问服务端所在网段（12.16.5.xx）
-       [App_c_a]<..up..> [socks_proxy_a]:访问访问本地所在网段（172.16.5.xx）
-       [Chrome_c_a]<..up..> [socks_proxy_a]:访问访问另一个客户端所在网段（162.16.5.xx）
-
-
-    }
-}
-
-package "上海客户端" as "上海客户端"{
-
-    node "162.16.5.xx"{
-       [162.16.5.1]
-       [wlcn_c_b] as "wlcn客户端9001"
-
-       actor Navicat_c_b as "本地Navicat"
-       actor App_c_b as "本地App"
-       actor Chrome_c_b as "本地浏览器"
-       [socks_proxy_b] as "上海本地用户socks代理软件"
-
-       [socks_proxy_b]<--up--> [wlcn_c_b]:访客通过软件代理本地socks网络
-
-       [Navicat_c_b]<..up..> [socks_proxy_b]:访问服务端所在网段（12.16.5.xx）
-       [App_c_b]<..up..> [socks_proxy_b]:访问访问本地所在网段（172.16.5.xx）
-       [Chrome_c_b]<..up..> [socks_proxy_b]:访问访问另一个客户端所在网段（162.16.5.xx）
-
-
-    }
-
-}
-
-package "第三方局域网"{
-
-    node "152.16.5.xx"{
-       [152.16.5.1]
-
-       actor Navicat_c_c as "本地Navicat"
-       actor App_c_c as "本地App"
-       actor Chrome_c_c as "本地浏览器"
-       [socks_proxy_c] as "上海本地用户socks代理软件"
-
-
-       [Navicat_c_c]<..up..> [socks_proxy_c]:访问服务端所在网段（12.16.5.xx）
-       [App_c_c]<..up..> [socks_proxy_c]:访问访问上海在网段（172.16.5.xx）
-       [Chrome_c_c]<..up..> [socks_proxy_c]:访问访问杭州客户端所在网段（162.16.5.xx）
-    }
-}
-
-       [wlcn_s_a] <==down==> [wlcn_c_a]: 客户端连接服务端
-       [wlcn_s_a] <==down==> [wlcn_c_b]: 客户端连接服务端
-       [wlcn_s_a]<--down--> [socks_proxy_c]:访客通过软件代理本地socks网络
-
-
-@enduml

wu-lazy-cloud-heartbeat-client/README.md

@@ -10,8 +10,8 @@ mvn native:build -Pnative
 ### 构建docker镜像
 
 ```shell
-docker build -t docker-registry.wujiawei.com/lazy/lazy-under-cloud-heartbeat-client:lazy-2.4.2-NATIVE-SNAPSHOT_latest -f Native-Dockerfile .
-docker push docker-registry.wujiawei.com/lazy/lazy-under-cloud-heartbeat-client:lazy-2.4.2-NATIVE-SNAPSHOT_latest
+docker build -t docker-registry.wujiawei.com/lazy/lazy-under-cloud-heartbeat-client:lazy-2.4.2-native-SNAPSHOT_latest -f Native-Dockerfile .
+docker push docker-registry.wujiawei.com/lazy/lazy-under-cloud-heartbeat-client:lazy-2.4.2-native-SNAPSHOT_latest
 ```
 
 ## BUILD IMAGE

wu-lazy-cloud-heartbeat-client/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>top.wu2020</groupId>
         <artifactId>wu-lazy-cloud-network</artifactId>
-        <version>1.3.1-JDK24-SNAPSHOT</version>
+        <version>1.2.9-JDK17</version>
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
@@ -13,8 +13,8 @@
     <description>云下心跳客户端</description>
 
     <properties>
-        <maven.compiler.source>24</maven.compiler.source>
-        <maven.compiler.target>24</maven.compiler.target>
+        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.target>17</maven.compiler.target>
     </properties>
 
     <dependencies>
@@ -23,16 +23,15 @@
             <groupId>top.wu2020</groupId>
             <artifactId>wu-lazy-cloud-heartbeat-common</artifactId>
         </dependency>
-        <dependency>
-            <groupId>top.wu2020</groupId>
-            <artifactId>wu-lazy-cloud-heartbeat-protocol-proxy</artifactId>
-            <version>1.3.1-JDK24-SNAPSHOT</version>
-        </dependency>
         <dependency>
             <groupId>com.alibaba</groupId>
             <artifactId>fastjson</artifactId>
             <version>2.0.50</version>
         </dependency>
+        <dependency>
+            <groupId>top.wu2020</groupId>
+            <artifactId>wu-framework-web-spring-starter</artifactId>
+        </dependency>
 
         <!--    h2数据库驱动    -->
         <dependency>
@@ -41,11 +40,7 @@
         </dependency>
         <dependency>
             <groupId>top.wu2020</groupId>
-            <artifactId>wu-framework-web-spring-starter</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>top.wu2020</groupId>
-            <artifactId>wu-database-lazy-orm-plus-starter</artifactId>
+            <artifactId>wu-database-lazy-plus-starter</artifactId>
         </dependency>
 
     </dependencies>

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/EnableHeartbeatClientAutoConfiguration.java

@@ -5,5 +5,5 @@ import org.wu.framework.lazy.orm.core.stereotype.LazyScan;
 
 @ComponentScan(basePackages = "org.framework.lazy.cloud.network.heartbeat.client")
 @LazyScan(scanBasePackages = "org.framework.lazy.cloud.network.heartbeat.client.infrastructure.entity")
-public class EnableClientAutoConfiguration {
+public class EnableHeartbeatClientAutoConfiguration {
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/application/ClientChangeApplication.java

@@ -1,7 +1,7 @@
 package org.framework.lazy.cloud.network.heartbeat.client.application;
 
 
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.event.ClientChangeEvent;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.event.ClientChangeEvent;
 
 /**
  *  客户端状态变更事件

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/application/assembler/LazyNettyServerPropertiesDTOAssembler.java

@@ -7,86 +7,87 @@ import org.framework.lazy.cloud.network.heartbeat.client.application.command.laz
 import org.framework.lazy.cloud.network.heartbeat.client.application.command.lazy.netty.server.properties.LazyNettyServerPropertiesQueryListCommand;
 import org.framework.lazy.cloud.network.heartbeat.client.application.command.lazy.netty.server.properties.LazyNettyServerPropertiesQueryOneCommand;
 import org.framework.lazy.cloud.network.heartbeat.client.application.dto.LazyNettyServerPropertiesDTO;
-import org.wu.framework.core.mapper.LazyStructMappers;
-import org.wu.framework.core.mapper.LazyStructMapper;
-
+import org.mapstruct.factory.Mappers;
+import org.mapstruct.Mapper;
 /**
- * describe 服务端配置信息
+ * describe 服务端配置信息 
  *
  * @author Jia wei Wu
  * @date 2024/04/03 03:00 下午
- * @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyAssembler
+ * @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyAssembler 
  **/
-@LazyStructMapper
+@Mapper
 public interface LazyNettyServerPropertiesDTOAssembler {
 
 
     /**
      * describe MapStruct 创建的代理对象
      *
+     
+     
+     
      * @author Jia wei Wu
      * @date 2024/04/03 03:00 下午
      **/
-    LazyNettyServerPropertiesDTOAssembler INSTANCE = LazyStructMappers.getMapper(LazyNettyServerPropertiesDTOAssembler.class);
-//    LazyNettyServerPropertiesDTOAssembler INSTANCE = new LazyNettyServerPropertiesDTOAssemblerImpl();
-
+    LazyNettyServerPropertiesDTOAssembler INSTANCE = Mappers.getMapper(LazyNettyServerPropertiesDTOAssembler.class);
     /**
      * describe 应用层存储入参转换成 领域对象
      *
-     * @param lazyNettyServerPropertiesStoryCommand 保存服务端配置信息对象
+     * @param lazyNettyServerPropertiesStoryCommand 保存服务端配置信息对象     
      * @return {@link LazyNettyServerProperties} 服务端配置信息领域对象
+     
      * @author Jia wei Wu
      * @date 2024/04/03 03:00 下午
      **/
-    LazyNettyServerProperties toLazyNettyServerProperties(LazyNettyServerPropertiesStoryCommand lazyNettyServerPropertiesStoryCommand);
-
+     LazyNettyServerProperties toLazyNettyServerProperties(LazyNettyServerPropertiesStoryCommand lazyNettyServerPropertiesStoryCommand);
     /**
      * describe 应用层更新入参转换成 领域对象
      *
-     * @param lazyNettyServerPropertiesUpdateCommand 更新服务端配置信息对象
-     * @return {@link LazyNettyServerProperties} 服务端配置信息领域对象
+     * @param lazyNettyServerPropertiesUpdateCommand 更新服务端配置信息对象     
+     * @return {@link LazyNettyServerProperties} 服务端配置信息领域对象     
+     
      * @author Jia wei Wu
      * @date 2024/04/03 03:00 下午
      **/
-    LazyNettyServerProperties toLazyNettyServerProperties(LazyNettyServerPropertiesUpdateCommand lazyNettyServerPropertiesUpdateCommand);
-
+     LazyNettyServerProperties toLazyNettyServerProperties(LazyNettyServerPropertiesUpdateCommand lazyNettyServerPropertiesUpdateCommand);
     /**
      * describe 应用层查询入参转换成 领域对象
      *
-     * @param lazyNettyServerPropertiesQueryOneCommand 查询单个服务端配置信息对象参数
-     * @return {@link LazyNettyServerProperties} 服务端配置信息领域对象
+     * @param lazyNettyServerPropertiesQueryOneCommand 查询单个服务端配置信息对象参数     
+     * @return {@link LazyNettyServerProperties} 服务端配置信息领域对象     
+     
      * @author Jia wei Wu
      * @date 2024/04/03 03:00 下午
      **/
-    LazyNettyServerProperties toLazyNettyServerProperties(LazyNettyServerPropertiesQueryOneCommand lazyNettyServerPropertiesQueryOneCommand);
-
+     LazyNettyServerProperties toLazyNettyServerProperties(LazyNettyServerPropertiesQueryOneCommand lazyNettyServerPropertiesQueryOneCommand);
     /**
      * describe 应用层查询入参转换成 领域对象
      *
-     * @param lazyNettyServerPropertiesQueryListCommand 查询集合服务端配置信息对象参数
-     * @return {@link LazyNettyServerProperties} 服务端配置信息领域对象
+     * @param lazyNettyServerPropertiesQueryListCommand 查询集合服务端配置信息对象参数     
+     * @return {@link LazyNettyServerProperties} 服务端配置信息领域对象     
+     
      * @author Jia wei Wu
      * @date 2024/04/03 03:00 下午
      **/
-    LazyNettyServerProperties toLazyNettyServerProperties(LazyNettyServerPropertiesQueryListCommand lazyNettyServerPropertiesQueryListCommand);
-
+     LazyNettyServerProperties toLazyNettyServerProperties(LazyNettyServerPropertiesQueryListCommand lazyNettyServerPropertiesQueryListCommand);
     /**
      * describe 应用层删除入参转换成 领域对象
      *
-     * @param lazyNettyServerPropertiesRemoveCommand 删除服务端配置信息对象参数
-     * @return {@link LazyNettyServerProperties} 服务端配置信息领域对象
+     * @param lazyNettyServerPropertiesRemoveCommand 删除服务端配置信息对象参数     
+     * @return {@link LazyNettyServerProperties} 服务端配置信息领域对象     
+     
      * @author Jia wei Wu
      * @date 2024/04/03 03:00 下午
      **/
-    LazyNettyServerProperties toLazyNettyServerProperties(LazyNettyServerPropertiesRemoveCommand lazyNettyServerPropertiesRemoveCommand);
-
+     LazyNettyServerProperties toLazyNettyServerProperties(LazyNettyServerPropertiesRemoveCommand lazyNettyServerPropertiesRemoveCommand);
     /**
      * describe 持久层领域对象转换成DTO对象
      *
-     * @param lazyNettyServerProperties 服务端配置信息领域对象
-     * @return {@link LazyNettyServerPropertiesDTO} 服务端配置信息DTO对象
+     * @param lazyNettyServerProperties 服务端配置信息领域对象     
+     * @return {@link LazyNettyServerPropertiesDTO} 服务端配置信息DTO对象     
+     
      * @author Jia wei Wu
      * @date 2024/04/03 03:00 下午
      **/
-    LazyNettyServerPropertiesDTO fromLazyNettyServerProperties(LazyNettyServerProperties lazyNettyServerProperties);
+     LazyNettyServerPropertiesDTO fromLazyNettyServerProperties(LazyNettyServerProperties lazyNettyServerProperties);
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/application/command/lazy/netty/server/properties/LazyNettyServerPropertiesQueryListCommand.java

@@ -1,12 +1,14 @@
 package org.framework.lazy.cloud.network.heartbeat.client.application.command.lazy.netty.server.properties;
 
-import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import lombok.experimental.Accessors;
-import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
+import io.swagger.v3.oas.annotations.media.Schema;
 import org.framework.lazy.cloud.network.heartbeat.common.enums.NettyClientStatus;
+import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
 
+import java.lang.String;
 import java.time.LocalDateTime;
+import java.lang.Integer;
 /**
  * describe 服务端配置信息 
  *
@@ -19,6 +21,7 @@ import java.time.LocalDateTime;
 @Schema(title = "lazy_netty_server_properties_query_List_command",description = "服务端配置信息")
 public class LazyNettyServerPropertiesQueryListCommand {
 
+
     /**
      * 
      * 客户身份ID

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/application/command/lazy/netty/server/properties/LazyNettyServerPropertiesQueryOneCommand.java

@@ -5,7 +5,6 @@ import lombok.experimental.Accessors;
 import io.swagger.v3.oas.annotations.media.Schema;
 import org.framework.lazy.cloud.network.heartbeat.common.enums.NettyClientStatus;
 import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
-import org.wu.framework.core.NormalUsedString;
 
 import java.lang.String;
 import java.time.LocalDateTime;
@@ -23,7 +22,6 @@ import java.lang.Integer;
 public class LazyNettyServerPropertiesQueryOneCommand {
 
 
-
     /**
      * 
      * 客户身份ID

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/application/command/lazy/netty/server/properties/LazyNettyServerPropertiesRemoveCommand.java

@@ -5,7 +5,6 @@ import lombok.experimental.Accessors;
 import io.swagger.v3.oas.annotations.media.Schema;
 import org.framework.lazy.cloud.network.heartbeat.common.enums.NettyClientStatus;
 import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
-import org.wu.framework.core.NormalUsedString;
 
 import java.lang.String;
 import java.time.LocalDateTime;
@@ -23,7 +22,6 @@ import java.lang.Integer;
 public class LazyNettyServerPropertiesRemoveCommand {
 
 
-
     /**
      * 
      * 客户身份ID

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/application/command/lazy/netty/server/properties/LazyNettyServerPropertiesStoryCommand.java

@@ -5,7 +5,6 @@ import lombok.experimental.Accessors;
 import io.swagger.v3.oas.annotations.media.Schema;
 import org.framework.lazy.cloud.network.heartbeat.common.enums.NettyClientStatus;
 import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
-import org.wu.framework.core.NormalUsedString;
 
 import java.lang.String;
 import java.time.LocalDateTime;
@@ -23,7 +22,6 @@ import java.lang.Integer;
 public class LazyNettyServerPropertiesStoryCommand {
 
 
-
     /**
      * 
      * 客户身份ID

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/application/command/lazy/netty/server/properties/LazyNettyServerPropertiesUpdateCommand.java

@@ -5,7 +5,6 @@ import lombok.experimental.Accessors;
 import io.swagger.v3.oas.annotations.media.Schema;
 import org.framework.lazy.cloud.network.heartbeat.common.enums.NettyClientStatus;
 import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
-import org.wu.framework.core.NormalUsedString;
 
 import java.lang.String;
 import java.time.LocalDateTime;
@@ -23,7 +22,6 @@ import java.lang.Integer;
 public class LazyNettyServerPropertiesUpdateCommand {
 
 
-
     /**
      * 
      * 客户身份ID

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/application/dto/LazyNettyServerPropertiesDTO.java

@@ -1,12 +1,14 @@
 package org.framework.lazy.cloud.network.heartbeat.client.application.dto;
 
-import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import lombok.experimental.Accessors;
-import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
+import io.swagger.v3.oas.annotations.media.Schema;
 import org.framework.lazy.cloud.network.heartbeat.common.enums.NettyClientStatus;
+import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
 
+import java.lang.String;
 import java.time.LocalDateTime;
+import java.lang.Integer;
 /**
  * describe 服务端配置信息 
  *
@@ -20,7 +22,6 @@ import java.time.LocalDateTime;
 public class LazyNettyServerPropertiesDTO {
 
 
-
     /**
      * 
      * 客户身份ID

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/application/impl/LazyNettyServerPropertiesApplicationImpl.java

@@ -2,23 +2,21 @@ package org.framework.lazy.cloud.network.heartbeat.client.application.impl;
 
 import jakarta.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.client.application.LazyNettyServerPropertiesApplication;
 import org.framework.lazy.cloud.network.heartbeat.client.application.assembler.LazyNettyServerPropertiesDTOAssembler;
-import org.framework.lazy.cloud.network.heartbeat.client.application.command.lazy.netty.server.properties.*;
 import org.framework.lazy.cloud.network.heartbeat.client.application.dto.LazyNettyServerPropertiesDTO;
-import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
-import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
 import org.framework.lazy.cloud.network.heartbeat.client.domain.model.lazy.netty.server.properties.LazyNettyServerProperties;
 import org.framework.lazy.cloud.network.heartbeat.client.domain.model.lazy.netty.server.properties.LazyNettyServerPropertiesRepository;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.NettyClientSocket;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.event.ClientChangeEvent;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.socket.NettyTcpClientSocket;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.udp.socket.NettyUdpClientSocket;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientSocket;
+import org.framework.lazy.cloud.network.heartbeat.client.application.LazyNettyServerPropertiesApplication;
+import org.framework.lazy.cloud.network.heartbeat.client.application.command.lazy.netty.server.properties.*;
+import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
+import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.event.ClientChangeEvent;
 import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
 import org.framework.lazy.cloud.network.heartbeat.common.enums.NettyClientStatus;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.ProtocolType;
+import org.wu.framework.core.NormalUsedString;
+import org.wu.framework.database.lazy.web.plus.stereotype.LazyApplication;
 import org.wu.framework.lazy.orm.database.lambda.domain.LazyPage;
-import org.wu.framework.lazy.orm.web.plus.stereotype.LazyApplication;
 import org.wu.framework.web.response.Result;
 
 import java.util.List;
@@ -141,7 +139,7 @@ public class LazyNettyServerPropertiesApplicationImpl implements LazyNettyServer
     @Override
     public Result<List<LazyNettyServerPropertiesDTO>> findList(LazyNettyServerPropertiesQueryListCommand lazyNettyServerPropertiesQueryListCommand) {
         LazyNettyServerProperties lazyNettyServerProperties = LazyNettyServerPropertiesDTOAssembler.INSTANCE.toLazyNettyServerProperties(lazyNettyServerPropertiesQueryListCommand);
-        return lazyNettyServerPropertiesRepository.findList(lazyNettyServerProperties).convert(lazyNettyServerPropertiesList -> lazyNettyServerPropertiesList.stream().map(LazyNettyServerPropertiesDTOAssembler.INSTANCE::fromLazyNettyServerProperties).collect(Collectors.toList()));
+        return lazyNettyServerPropertiesRepository.findList(lazyNettyServerProperties).convert(lazyNettyServerPropertiess -> lazyNettyServerPropertiess.stream().map(LazyNettyServerPropertiesDTOAssembler.INSTANCE::fromLazyNettyServerProperties).collect(Collectors.toList()));
     }
 
     /**
@@ -190,33 +188,16 @@ public class LazyNettyServerPropertiesApplicationImpl implements LazyNettyServer
             String clientId = lazyNettyServerProperties.getClientId();
             String appKey = lazyNettyServerProperties.getAppKey();
             String appSecret = lazyNettyServerProperties.getAppSecret();
-            ProtocolType protocolType = lazyNettyServerProperties.getProtocolType();
-            NettyClientSocket nettyClientSocket;
-            if (ProtocolType.TCP.equals(protocolType)) {
-                nettyClientSocket = new
-                        NettyTcpClientSocket(inetHost, inetPort, clientId,
-                         appKey, appSecret,
-                        clientChangeEvent, handleChannelTypeAdvancedList);
-            } else if (ProtocolType.UDP.equals(protocolType)) {
-                nettyClientSocket = new
-                        NettyUdpClientSocket(inetHost, inetPort, clientId,
-                      appKey, appSecret,
-                        clientChangeEvent, handleChannelTypeAdvancedList);
-            } else {
-                nettyClientSocket = null;
-            }
-
-            if (nettyClientSocket == null) {
-                return;
-            }
 
+            NettyClientSocket nettyClientSocket = new
+                    NettyClientSocket(inetHost, inetPort, clientId,
+                    NormalUsedString.DEFAULT,appKey,appSecret,
+                    clientChangeEvent, handleChannelTypeAdvancedList);
             cacheNettyClientSocketMap.put(lazyNettyServerProperties, nettyClientSocket);
 
             // 更新状态为运行中
             lazyNettyServerProperties.setConnectStatus(NettyClientStatus.RUNNING);
             lazyNettyServerPropertiesRepository.story(lazyNettyServerProperties);
-
-
             Thread thread = new Thread(() -> {
                 try {
                     nettyClientSocket.newConnect2Server();
@@ -256,7 +237,7 @@ public class LazyNettyServerPropertiesApplicationImpl implements LazyNettyServer
     @Override
     public void destroyOneClientSocket(LazyNettyServerProperties needCloseLazyNettyServerProperties) {
         // 关闭指定socket
-        cacheNettyClientSocketMap.forEach(((nettyServerProperties, nettyTcpClientSocket) -> {
+        cacheNettyClientSocketMap.forEach(((nettyServerProperties, nettyClientSocket) -> {
             String clientId = nettyServerProperties.getClientId();
             String inetHost = nettyServerProperties.getInetHost();
             Integer inetPort = nettyServerProperties.getInetPort();
@@ -266,7 +247,7 @@ public class LazyNettyServerPropertiesApplicationImpl implements LazyNettyServer
             if (Objects.equals(clientId, needCloseClientId)
                     && Objects.equals(inetPort, needCloseInetPort)
                     && Objects.equals(inetHost, needCloseInetHost)) {
-                nettyTcpClientSocket.shutdown();
+                nettyClientSocket.shutdown();
                 // 关闭客户端:{}与服务端连接:{}:{}
                 log.warn("Close client: {} Connect to server: {}: {}", clientId, inetHost, inetPort);
             }
@@ -279,8 +260,8 @@ public class LazyNettyServerPropertiesApplicationImpl implements LazyNettyServer
     @Override
     public void destroyClientSocket() {
         // 关闭socket
-        cacheNettyClientSocketMap.forEach(((nettyServerProperties, nettyTcpClientSocket) -> {
-            nettyTcpClientSocket.shutdown();
+        cacheNettyClientSocketMap.forEach(((nettyServerProperties, nettyClientSocket) -> {
+            nettyClientSocket.shutdown();
             String clientId = nettyServerProperties.getClientId();
             String inetHost = nettyServerProperties.getInetHost();
             Integer inetPort = nettyServerProperties.getInetPort();

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/config/ClientAutoConfiguration.java

@@ -1,459 +1,86 @@
 package org.framework.lazy.cloud.network.heartbeat.client.config;
 
 
-import org.framework.lazy.cloud.network.heartbeat.client.context.NettyClientSocketApplicationListener;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.event.ClientChangeEvent;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced.*;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.udp.advanced.*;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.http.advanced.*;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.advanced.*;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientSocket;
+import org.springframework.boot.CommandLineRunner;
 import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.context.annotation.Import;
-import org.springframework.context.annotation.Role;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.event.ClientChangeEvent;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.wu.framework.core.NormalUsedString;
 
-@Import({NettyClientSocketApplicationListener.class})
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
-@ConditionalOnProperty(prefix = NettyClientProperties.PREFIX, name = "enabled", havingValue = "true", matchIfMissing = true)
-public class ClientAutoConfiguration {
+import java.util.List;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * description 自动配置
+ *
+ * @author 吴佳伟
+ * @date 2023/09/12 18:22
+ * @see InitConfig
+ */
+@Deprecated
+@Slf4j
+public class ClientAutoConfiguration implements CommandLineRunner {
+
+    private final NettyClientProperties nettyClientProperties;
+    private final ClientChangeEvent clientChangeEvent;
+
+    private final List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList; // 处理服务端发送过来的数据类型
 
 
-    @Configuration()
-    static class ClientTcpConfiguration {
-        /**
-         * 服务端 处理客户端心跳
-         *
-         * @return ClientHandleTcpChannelHeartbeatTypeAdvanced
-         */
-        @Bean
-        public ClientHandleTcpChannelHeartbeatTypeAdvanced clientHandleTcpChannelHeartbeatTypeAdvanced() {
-            return new ClientHandleTcpChannelHeartbeatTypeAdvanced();
-        }
+    public static final ThreadPoolExecutor NETTY_CLIENT_EXECUTOR = new ThreadPoolExecutor(1, 1, 200, TimeUnit.MILLISECONDS,
+            new ArrayBlockingQueue<>(1));
 
-        /**
-         * 处理 客户端代理的真实端口自动读写
-         *
-         * @return ClientHandleTcpDistributeSingleClientRealAutoReadConnectTypeAdvanced
-         */
-        @Bean
-        public ClientHandleTcpDistributeSingleClientRealAutoReadConnectTypeAdvanced clientHandleTcpDistributeSingleClientRealAutoReadConnectTypeAdvanced() {
-            return new ClientHandleTcpDistributeSingleClientRealAutoReadConnectTypeAdvanced();
-        }
-
-        /**
-         * 处理 接收服务端发送过来的聊天信息
-         *
-         * @return ClientHandleTcpDistributeSingleClientMessageTypeAdvanced
-         */
-        @Bean
-        public ClientHandleTcpDistributeSingleClientMessageTypeAdvanced clientHandleTcpDistributeSingleClientMessageTypeAdvanced() {
-            return new ClientHandleTcpDistributeSingleClientMessageTypeAdvanced();
-        }
-
-        /**
-         * 处理 客户端渗透服务端数据传输通道连接成功
-         *
-         * @return ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced
-         */
-        @Bean
-        public ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced clientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced() {
-            return new ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced();
-        }
-
-        /**
-         * 处理 客户端渗透客户端数据传输通道连接成功
-         *
-         * @return ClientHandleTcpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced
-         */
-        @Bean
-        public ClientHandleTcpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced clientHandleTcpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced() {
-            return new ClientHandleTcpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleTcpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced clientHandleTcpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced() {
-            return new ClientHandleTcpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleTcpDistributeClientTransferClientRequestTypeAdvanced clientHandleTcpDistributeClientTransferClientRequestTypeAdvanced() {
-            return new ClientHandleTcpDistributeClientTransferClientRequestTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleTcpDistributeServicePermeateClientTransferClientResponseTypeAdvanced clientHandleTcpDistributeServicePermeateClientTransferClientResponseTypeAdvanced() {
-            return new ClientHandleTcpDistributeServicePermeateClientTransferClientResponseTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleTcpDistributeSingleClientRealCloseVisitorTypeAdvanced clientHandleTcpDistributeSingleClientRealCloseVisitorTypeAdvanced() {
-            return new ClientHandleTcpDistributeSingleClientRealCloseVisitorTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleTcpChannelTransferTypeAdvancedHandleDistributeTcpDistribute clientHandleTcpChannelTransferTypeAdvancedHandleDistributeTcpDistribute(NettyClientProperties nettyClientProperties) {
-            return new ClientHandleTcpChannelTransferTypeAdvancedHandleDistributeTcpDistribute(nettyClientProperties);
-        }
-
-        @Bean
-        public ClientHandleTcpDistributeConnectSuccessNotificationTypeAdvancedHandle clientHandleTcpDistributeConnectSuccessNotificationTypeAdvancedHandle(ClientChangeEvent clientChangeEvent) {
-            return new ClientHandleTcpDistributeConnectSuccessNotificationTypeAdvancedHandle(clientChangeEvent);
-        }
-
-        @Bean
-        public ClientHandleTcpClientChannelActiveAdvanced clientHandleTcpClientChannelActiveAdvanced(NettyClientProperties nettyClientProperties) {
-            return new ClientHandleTcpClientChannelActiveAdvanced(nettyClientProperties);
-        }
-
-        @Bean
-        public ClientHandleTcpDistributeDisconnectTypeAdvancedHandle clientHandleTcpDistributeDisconnectTypeAdvancedHandle(ClientChangeEvent clientChangeEvent) {
-            return new ClientHandleTcpDistributeDisconnectTypeAdvancedHandle(clientChangeEvent);
-        }
-
-        @Bean
-        public ClientHandleTcpDistributeStagingClosedTypeAdvanced clientHandleTcpDistributeStagingClosedTypeAdvanced() {
-            return new ClientHandleTcpDistributeStagingClosedTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleTcpDistributeStagingOpenedTypeAdvanced clientHandleTcpDistributeStagingOpenedTypeAdvanced() {
-            return new ClientHandleTcpDistributeStagingOpenedTypeAdvanced();
-        }
-
-        /**
-         * 处理 客户端渗透服务端init信息
-         *
-         * @return ClientHandleTcpDistributeClientPermeateServerInitTypeAdvanced
-         */
-        @Bean
-        public ClientHandleTcpDistributeClientPermeateServerInitTypeAdvanced clientHandleTcpDistributeClientPermeateServerInitTypeAdvanced(NettyClientProperties nettyClientProperties) {
-            return new ClientHandleTcpDistributeClientPermeateServerInitTypeAdvanced(nettyClientProperties);
-        }
-
-        /**
-         * 处理 客户端渗透服务端init close 信息
-         *
-         * @return ClientHandleTcpDistributeClientPermeateServerCloseTypeAdvanced
-         */
-        @Bean
-        public ClientHandleTcpDistributeClientPermeateServerCloseTypeAdvanced clientHandleTcpDistributeClientPermeateServerCloseTypeAdvanced() {
-            return new ClientHandleTcpDistributeClientPermeateServerCloseTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleTcpDistributeClientPermeateServerTransferTypeAdvanced clientHandleTcpDistributeClientPermeateServerTransferTypeAdvanced() {
-            return new ClientHandleTcpDistributeClientPermeateServerTransferTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleTcpDistributeClientPermeateClientCloseTypeAdvanced clientHandleTcpDistributeClientPermeateClientCloseTypeAdvanced() {
-            return new ClientHandleTcpDistributeClientPermeateClientCloseTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleTcpDistributeClientPermeateClientInitTypeAdvanced clientHandleTcpDistributeClientPermeateClientInitTypeAdvanced() {
-            return new ClientHandleTcpDistributeClientPermeateClientInitTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleTcpDistributeClientPermeateClientTransferCloseTypeAdvanced clientHandleTcpDistributeClientPermeateClientTransferCloseTypeAdvanced() {
-            return new ClientHandleTcpDistributeClientPermeateClientTransferCloseTypeAdvanced();
-        }
-
-
-        @Bean
-        public ClientHandleTcpDistributeServicePermeateClientRealConnectTypeAdvanced clientHandleTcpDistributeServicePermeateClientRealConnectTypeAdvanced(
-                NettyClientProperties nettyClientProperties) {
-            return new ClientHandleTcpDistributeServicePermeateClientRealConnectTypeAdvanced(nettyClientProperties);
-        }
-
-        @Bean
-        public ClientHandleTcpDistributeClientPermeateServerTransferCloseTypeAdvanced clientHandleTcpDistributeClientPermeateServerTransferCloseTypeAdvanced() {
-            return new ClientHandleTcpDistributeClientPermeateServerTransferCloseTypeAdvanced();
-        }
+    public ClientAutoConfiguration(NettyClientProperties nettyClientProperties,
+                                   ClientChangeEvent clientChangeEvent,
+                                   List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList) {
+        this.nettyClientProperties = nettyClientProperties;
+        this.clientChangeEvent = clientChangeEvent;
+        this.handleChannelTypeAdvancedList = handleChannelTypeAdvancedList;
     }
 
-    @Configuration()
-    static class ClientUdpConfiguration {
-        /**
-         * 服务端 处理客户端心跳
-         *
-         * @return ClientHandleUdpChannelHeartbeatTypeAdvanced
-         */
-        @Bean
-        public ClientHandleUdpChannelHeartbeatTypeAdvanced clientHandleUdpChannelHeartbeatTypeAdvanced() {
-            return new ClientHandleUdpChannelHeartbeatTypeAdvanced();
-        }
 
-        /**
-         * 处理 客户端代理的真实端口自动读写
-         *
-         * @return ClientHandleUdpDistributeSingleClientRealAutoReadConnectTypeAdvanced
-         */
-        @Bean
-        public ClientHandleUdpDistributeSingleClientRealAutoReadConnectTypeAdvanced clientHandleUdpDistributeSingleClientRealAutoReadConnectTypeAdvanced() {
-            return new ClientHandleUdpDistributeSingleClientRealAutoReadConnectTypeAdvanced();
-        }
-
-        /**
-         * 处理 接收服务端发送过来的聊天信息
-         *
-         * @return ClientHandleUdpDistributeSingleClientMessageTypeAdvanced
-         */
-        @Bean
-        public ClientHandleUdpDistributeSingleClientMessageTypeAdvanced clientHandleUdpDistributeSingleClientMessageTypeAdvanced() {
-            return new ClientHandleUdpDistributeSingleClientMessageTypeAdvanced();
-        }
-
-        /**
-         * 处理 客户端渗透服务端数据传输通道连接成功
-         *
-         * @return ClientHandleUdpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced
-         */
-        @Bean
-        public ClientHandleUdpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced clientHandleUdpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced() {
-            return new ClientHandleUdpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced();
-        }
-
-        /**
-         * 处理 客户端渗透客户端数据传输通道连接成功
-         *
-         * @return ClientHandleUdpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced
-         */
-        @Bean
-        public ClientHandleUdpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced clientHandleUdpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced() {
-            return new ClientHandleUdpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleUdpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced clientHandleUdpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced() {
-            return new ClientHandleUdpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleUdpDistributeClientTransferClientRequestTypeAdvanced clientHandleUdpDistributeClientTransferClientRequestTypeAdvanced() {
-            return new ClientHandleUdpDistributeClientTransferClientRequestTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleUdpDistributeServicePermeateClientTransferClientResponseTypeAdvanced clientHandleUdpDistributeServicePermeateClientTransferClientResponseTypeAdvanced() {
-            return new ClientHandleUdpDistributeServicePermeateClientTransferClientResponseTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleUdpDistributeSingleClientRealCloseVisitorTypeAdvanced clientHandleUdpDistributeSingleClientRealCloseVisitorTypeAdvanced() {
-            return new ClientHandleUdpDistributeSingleClientRealCloseVisitorTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleUdpChannelTransferTypeAdvancedHandleDistribute clientHandleUdpChannelTransferTypeAdvancedHandleDistribute(NettyClientProperties nettyClientProperties) {
-            return new ClientHandleUdpChannelTransferTypeAdvancedHandleDistribute(nettyClientProperties);
-        }
-
-        @Bean
-        public ClientHandleUdpDistributeConnectSuccessNotificationTypeAdvancedHandle clientHandleUdpDistributeConnectSuccessNotificationTypeAdvancedHandle(ClientChangeEvent clientChangeEvent) {
-            return new ClientHandleUdpDistributeConnectSuccessNotificationTypeAdvancedHandle(clientChangeEvent);
-        }
-
-        @Bean
-        public ClientHandleUdpClientChannelActiveAdvanced clientHandleUdpClientChannelActiveAdvanced(NettyClientProperties nettyClientProperties) {
-            return new ClientHandleUdpClientChannelActiveAdvanced(nettyClientProperties);
-        }
-
-        @Bean
-        public ClientHandleUdpDistributeDisconnectTypeAdvancedHandle clientHandleUdpDistributeDisconnectTypeAdvancedHandle(ClientChangeEvent clientChangeEvent) {
-            return new ClientHandleUdpDistributeDisconnectTypeAdvancedHandle(clientChangeEvent);
-        }
-
-        @Bean
-        public ClientHandleUdpDistributeStagingClosedTypeAdvanced clientHandleUdpDistributeStagingClosedTypeAdvanced() {
-            return new ClientHandleUdpDistributeStagingClosedTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleUdpDistributeStagingOpenedTypeAdvanced clientHandleUdpDistributeStagingOpenedTypeAdvanced() {
-            return new ClientHandleUdpDistributeStagingOpenedTypeAdvanced();
-        }
-
-        /**
-         * 处理 客户端渗透服务端init信息
-         *
-         * @return ClientHandleUdpDistributeClientPermeateServerInitTypeAdvanced
-         */
-        @Bean
-        public ClientHandleUdpDistributeClientPermeateServerInitTypeAdvanced clientHandleUdpDistributeClientPermeateServerInitTypeAdvanced(NettyClientProperties nettyClientProperties) {
-            return new ClientHandleUdpDistributeClientPermeateServerInitTypeAdvanced(nettyClientProperties);
-        }
-
-        /**
-         * 处理 客户端渗透服务端init close 信息
-         *
-         * @return ClientHandleUdpDistributeClientPermeateServerCloseTypeAdvanced
-         */
-        @Bean
-        public ClientHandleUdpDistributeClientPermeateServerCloseTypeAdvanced clientHandleUdpDistributeClientPermeateServerCloseTypeAdvanced() {
-            return new ClientHandleUdpDistributeClientPermeateServerCloseTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleUdpDistributeClientPermeateServerTransferTypeAdvanced clientHandleUdpDistributeClientPermeateServerTransferTypeAdvanced() {
-            return new ClientHandleUdpDistributeClientPermeateServerTransferTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleUdpDistributeClientPermeateClientCloseTypeAdvanced clientHandleUdpDistributeClientPermeateClientCloseTypeAdvanced() {
-            return new ClientHandleUdpDistributeClientPermeateClientCloseTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleUdpDistributeClientPermeateClientInitTypeAdvanced clientHandleUdpDistributeClientPermeateClientInitTypeAdvanced() {
-            return new ClientHandleUdpDistributeClientPermeateClientInitTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleUdpDistributeClientPermeateClientTransferCloseTypeAdvanced clientHandleUdpDistributeClientPermeateClientTransferCloseTypeAdvanced() {
-            return new ClientHandleUdpDistributeClientPermeateClientTransferCloseTypeAdvanced();
-        }
-
-
-        @Bean
-        public ClientHandleUdpDistributeServicePermeateClientRealConnectTypeAdvanced clientHandleUdpDistributeServicePermeateClientRealConnectTypeAdvanced(
-                NettyClientProperties nettyClientProperties) {
-            return new ClientHandleUdpDistributeServicePermeateClientRealConnectTypeAdvanced(nettyClientProperties);
-        }
-
-        @Bean
-        public ClientHandleUdpDistributeClientPermeateServerTransferCloseTypeAdvanced clientHandleUdpDistributeClientPermeateServerTransferCloseTypeAdvanced() {
-            return new ClientHandleUdpDistributeClientPermeateServerTransferCloseTypeAdvanced();
-        }
+    @Bean(destroyMethod = "shutdown")
+    public NettyClientSocket nettyClientSocket() {
+        String inetHost = nettyClientProperties.getInetHost();
+        int inetPort = nettyClientProperties.getInetPort();
+        String clientId = nettyClientProperties.getClientId();
+        String appKey = nettyClientProperties.getAppKey();
+        String appSecret = nettyClientProperties.getAppSecret();
+        return new NettyClientSocket(inetHost, inetPort, clientId, NormalUsedString.DEFAULT, appKey,appSecret,clientChangeEvent, handleChannelTypeAdvancedList);
     }
 
-    @Configuration
-    static class HttpProxyConfiguration {
+    /**
+     * @param args
+     * @throws Exception
+     */
+    @Override
+    public void run(String... args) throws Exception {
 
-        @Bean
-        public ClientHandleDistributeHttpClientProxyServerTransferTypeAdvanced clientHandleDistributeHttpClientProxyServerTypeAdvanced() {
-            return new ClientHandleDistributeHttpClientProxyServerTransferTypeAdvanced();
-        }
 
-        @Bean
-        public ClientHandleHttpClientProxyClientTypeAdvanced clientHandleHttpClientClientProxyClientTypeAdvanced() {
-            return new ClientHandleHttpClientProxyClientTypeAdvanced();
-        }
+        String inetHost = nettyClientProperties.getInetHost();
+        int inetPort = nettyClientProperties.getInetPort();
+        String clientId = nettyClientProperties.getClientId();
+        String appKey = nettyClientProperties.getAppKey();
+        String appSecret = nettyClientProperties.getAppSecret();
+        NettyClientSocket nettyClientSocket = new NettyClientSocket(
+                inetHost, inetPort,
+                clientId, NormalUsedString.DEFAULT,appKey,appSecret,
+                clientChangeEvent, handleChannelTypeAdvancedList);
+        Thread thread = new Thread(() -> {
+            try {
+                nettyClientSocket.newConnect2Server();
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
 
-        @Bean
-        public ClientHandleHttpClientProxyServerTypeAdvanced clientHandleHttpClientClientProxyServerTypeAdvanced() {
-            return new ClientHandleHttpClientProxyServerTypeAdvanced();
-        }
+        });
+        log.info("当前服务连接Netty客户端:{},Netty端口:{}", inetHost, inetPort);
+        NETTY_CLIENT_EXECUTOR.execute(thread);
 
-        @Bean
-        public ClientHandleDistributeHttpClientProxyServerServerRouteTypeAdvanced clientHandleDistributeHttpClientProxyServerServerRouteTypeAdvanced() {
-            return new ClientHandleDistributeHttpClientProxyServerServerRouteTypeAdvanced();
-        }
-        @Bean
-        public ClientHandleDistributeHttpClientProxyServerServerRouteCloseTypeAdvanced clientHandleDistributeHttpClientProxyServerServerRouteCloseTypeAdvanced(){
-            return new ClientHandleDistributeHttpClientProxyServerServerRouteCloseTypeAdvanced();
-        }
 
-        @Bean
-        public ClientHandleDistributeHttpClientProxyServerClientRouteTypeAdvanced clientHandleDistributeHttpClientProxyServerClientRouteTypeAdvanced() {
-            return new ClientHandleDistributeHttpClientProxyServerClientRouteTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleDistributeHttpClientProxyServerClientRouteCloseTypeAdvanced clientHandleDistributeHttpClientProxyServerClientRouteCloseTypeAdvanced(){
-            return new ClientHandleDistributeHttpClientProxyServerClientRouteCloseTypeAdvanced();
-        }
-        @Bean
-        public ClientHandleDistributeHttpClientProxyClientConnectionTransferSuccessfulAdvanced clientHandleDistributeHttpClientProxyClientConnectionTransferSuccessfulAdvanced() {
-            return new ClientHandleDistributeHttpClientProxyClientConnectionTransferSuccessfulAdvanced();
-        }
-
-        @Bean
-        public ClientHandleDistributeHttpClientProxyClientTransferRequestAdvanced clientHandleDistributeHttpClientProxyClientTransferRequestAdvanced() {
-            return new ClientHandleDistributeHttpClientProxyClientTransferRequestAdvanced();
-        }
-        @Bean
-        public ClientHandleHttpDistributeClientProxyClientTransferResponseTypeAdvanced clientHandleHttpDistributeClientProxyClientTransferResponseTypeAdvanced(){
-            return new ClientHandleHttpDistributeClientProxyClientTransferResponseTypeAdvanced();
-        }
-        @Bean
-        public ClientHandleHttpDistributeClientProxyClientTransferCLoseTypeAdvanced clientHandleHttpDistributeClientProxyClientTransferCLoseTypeAdvanced(){
-            return new ClientHandleHttpDistributeClientProxyClientTransferCLoseTypeAdvanced();
-        }
-        @Bean
-        public ClientHandleDistributeHttpServerProxyClientConnectionSuccessfulTypeAdvanced clientHandleDistributeHttpServerProxyClientConnectionSuccessfulTypeAdvanced(){
-            return new ClientHandleDistributeHttpServerProxyClientConnectionSuccessfulTypeAdvanced();
-        }
-        @Bean
-        public ClientHandleDistributeHttpServerProxyClientTransferRequestAdvanced clientHandleDistributeHttpServerProxyClientTransferRequestAdvanced(){
-            return new ClientHandleDistributeHttpServerProxyClientTransferRequestAdvanced();
-        }
-    }
-
-    @Configuration
-    static class SocksProxyConfiguration {
-        @Bean
-        public ClientHandleNettySocketProtocolHandleSocketClientProxyServerStartTypeAdvanced nettySocketProtocolHandleSocketClientProxyServerTypeAdvanced() {
-            return new ClientHandleNettySocketProtocolHandleSocketClientProxyServerStartTypeAdvanced();
-        }
-
-        @Bean
-        public ClientHandleDistributeSocksClientProxyServerConnectionTransferSuccessfulAdvanced clientHandleDistributeSocksClientProxyServerConnectionTransferSuccessfulAdvanced() {
-            return new ClientHandleDistributeSocksClientProxyServerConnectionTransferSuccessfulAdvanced();
-        }
-
-        @Bean
-        public ClientHandleDistributeSocksClientProxyServerConnectionTransferFailAdvanced clientHandleDistributeSocksClientProxyServerConnectionTransferFailAdvanced() {
-            return new ClientHandleDistributeSocksClientProxyServerConnectionTransferFailAdvanced();
-        }
-
-        @Bean
-        public ClientHandleDistributeSocksClientProxyServerTransferTransferResponseAdvanced clientHandleDistributeSocksClientProxyServerTransferTransferResponseAdvanced() {
-            return new ClientHandleDistributeSocksClientProxyServerTransferTransferResponseAdvanced();
-        }
-
-        @Bean
-        public ClientHandleDistributeSocksClientProxyServerTransferCloseAdvanced clientHandleDistributeSocksClientProxyServerTransferCloseAdvanced() {
-            return new ClientHandleDistributeSocksClientProxyServerTransferCloseAdvanced();
-        }
-        @Bean
-        public ClientHandleDistributeSocksClientProxyClientConnectionTransferFailAdvanced clientHandleDistributeSocksClientProxyClientConnectionTransferFailAdvanced(){
-            return new ClientHandleDistributeSocksClientProxyClientConnectionTransferFailAdvanced();
-        }
-        @Bean
-        public ClientHandleDistributeSocksClientProxyClientConnectionTransferSuccessfulAdvanced clientHandleDistributeSocksClientProxyClientConnectionTransferSuccessfulAdvanced(){
-            return new ClientHandleDistributeSocksClientProxyClientConnectionTransferSuccessfulAdvanced();
-        }
-        @Bean
-        public ClientHandleDistributeSocksClientProxyClientTransferCloseAdvanced clientHandleDistributeSocksClientProxyClientTransferCloseAdvanced(){
-            return new ClientHandleDistributeSocksClientProxyClientTransferCloseAdvanced();
-        }
-        @Bean
-        public ClientHandleDistributeSocksClientProxyClientTransferTransferResponseAdvanced clientHandleDistributeSocksClientProxyClientTransferTransferResponseAdvanced(){
-            return new ClientHandleDistributeSocksClientProxyClientTransferTransferResponseAdvanced();
-        }
-        @Bean
-        public ClientHandleDistributeSocksClientProxyClientOtherConnectionTransferAdvanced clientHandleDistributeSocksClientProxyClientOtherConnectionTransferAdvanced1(){
-            return new ClientHandleDistributeSocksClientProxyClientOtherConnectionTransferAdvanced();
-        }
-        @Bean
-        public ClientHandleDistributeSocksClientProxyClientTransferTransferRequestAdvanced clientHandleDistributeSocksClientProxyClientTransferTransferRequestAdvanced(){
-            return new ClientHandleDistributeSocksClientProxyClientTransferTransferRequestAdvanced();
-        }
-        @Bean
-        public ClientHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced clientHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced(){
-            return new ClientHandleSocksDistributeServerProxyClientConnectionInitTypeAdvanced();
-        }
-        @Bean
-        public ClientHandleSocksDistributeServerProxyClientRequestTypeAdvanced clientHandleSocksDistributeServerProxyClientRequestTypeAdvanced(){
-            return new ClientHandleSocksDistributeServerProxyClientRequestTypeAdvanced();
-        }
-        @Bean
-        public ClientHandleSocksDistributeServerProxyClientTransferCloseAdvanced clientHandleSocksDistributeServerProxyClientTransferCloseAdvanced(){
-            return new ClientHandleSocksDistributeServerProxyClientTransferCloseAdvanced();
-        }
     }
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/config/HeartbeatClientConfiguration.java

@@ -0,0 +1,165 @@
+package org.framework.lazy.cloud.network.heartbeat.client.config;
+
+
+import org.framework.lazy.cloud.network.heartbeat.client.netty.advanced.*;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.event.ClientChangeEvent;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Role;
+
+import java.util.List;
+
+@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+@ConditionalOnProperty(prefix = NettyClientProperties.PREFIX, name = "enabled", havingValue = "true", matchIfMissing = true)
+public class HeartbeatClientConfiguration {
+
+    /**
+     * 服务端 处理客户端心跳
+     *
+     * @return ClientTcpHandleChannelHeartbeatTypeAdvanced
+     */
+    @Bean
+    public ClientTcpHandleChannelHeartbeatTypeAdvanced clientChannelHeartbeatTypeAdvanced() {
+        return new ClientTcpHandleChannelHeartbeatTypeAdvanced();
+    }
+
+    /**
+     * 处理 客户端代理的真实端口自动读写
+     *
+     * @return ClientHandleTcpDistributeSingleClientRealAutoReadConnectTypeAdvanced
+     */
+    @Bean
+    public ClientHandleTcpDistributeSingleClientRealAutoReadConnectTypeAdvanced handleDistributeSingleClientRealAutoReadConnectTypeAdvanced() {
+        return new ClientHandleTcpDistributeSingleClientRealAutoReadConnectTypeAdvanced();
+    }
+
+    /**
+     * 处理 接收服务端发送过来的聊天信息
+     *
+     * @return ClientHandleTcpDistributeSingleClientMessageTypeAdvanced
+     */
+    @Bean
+    public ClientHandleTcpDistributeSingleClientMessageTypeAdvanced handleDistributeSingleClientMessageTypeAdvanced() {
+        return new ClientHandleTcpDistributeSingleClientMessageTypeAdvanced();
+    }
+    /**
+     * 处理 客户端渗透服务端数据传输通道连接成功
+     *
+     * @return ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced
+     */
+    @Bean
+    public ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced clientHandleDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced() {
+        return new ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced();
+    }
+
+    /**
+     * 处理 客户端渗透客户端数据传输通道连接成功
+     *
+     * @return ClientHandleTcpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced
+     */
+    @Bean
+    public ClientHandleTcpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced clientHandleDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced() {
+        return new ClientHandleTcpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced();
+    }
+
+    @Bean
+    public ClientHandleTcpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced clientHandleDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced() {
+        return new ClientHandleTcpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced();
+    }
+
+    @Bean
+    public ClientHandleTcpDistributeClientTransferClientRequestTypeAdvanced clientHandleDistributeClientTransferClientTypeAdvanced() {
+        return new ClientHandleTcpDistributeClientTransferClientRequestTypeAdvanced();
+    }
+
+    @Bean
+    public ClientHandleTcpDistributeServicePermeateClientTransferClientResponseTypeAdvanced clientHandleDistributeClientTransferClientResponseTypeAdvanced() {
+        return new ClientHandleTcpDistributeServicePermeateClientTransferClientResponseTypeAdvanced();
+    }
+    @Bean
+    public ClientHandleTcpDistributeSingleClientRealCloseVisitorTypeAdvanced handleDistributeSingleClientRealCloseVisitorTypeAdvanced() {
+        return new ClientHandleTcpDistributeSingleClientRealCloseVisitorTypeAdvanced();
+    }
+
+    @Bean
+    public ClientHandleChannelTransferTypeAdvancedHandleDistributeTcpDistribute handleChannelTransferTypeAdvancedHandleDistribute(NettyClientProperties nettyClientProperties) {
+        return new ClientHandleChannelTransferTypeAdvancedHandleDistributeTcpDistribute(nettyClientProperties);
+    }
+
+    @Bean
+    public HandleTcpDistributeConnectSuccessNotificationTypeAdvancedHandle handleDistributeConnectSuccessNotificationTypeAdvancedHandle(ClientChangeEvent clientChangeEvent) {
+        return new HandleTcpDistributeConnectSuccessNotificationTypeAdvancedHandle(clientChangeEvent);
+    }
+
+    @Bean
+    public HandleTcpClientChannelActiveAdvanced handleClientChannelActiveAdvanced(NettyClientProperties nettyClientProperties) {
+        return new HandleTcpClientChannelActiveAdvanced(nettyClientProperties);
+    }
+
+    @Bean
+    public HandleTcpDistributeDisconnectTypeAdvancedHandle handleDistributeDisconnectTypeAdvancedHandle(ClientChangeEvent clientChangeEvent) {
+        return new HandleTcpDistributeDisconnectTypeAdvancedHandle(clientChangeEvent);
+    }
+
+    @Bean
+    public HandleTcpDistributeStagingClosedTypeAdvanced handleDistributeStagingClosedTypeAdvanced() {
+        return new HandleTcpDistributeStagingClosedTypeAdvanced();
+    }
+
+    @Bean
+    public HandleTcpDistributeStagingOpenedTypeAdvanced handleDistributeStagingOpenedTypeAdvanced() {
+        return new HandleTcpDistributeStagingOpenedTypeAdvanced();
+    }
+
+    /**
+     * 处理 客户端渗透服务端init信息
+     *
+     * @return ClientHandleTcpDistributeClientPermeateServerInitTypeAdvanced
+     */
+    @Bean
+    public ClientHandleTcpDistributeClientPermeateServerInitTypeAdvanced clientHandleDistributeClientPermeateServerInitTypeAdvanced(NettyClientProperties nettyClientProperties) {
+        return new ClientHandleTcpDistributeClientPermeateServerInitTypeAdvanced(nettyClientProperties);
+    }
+    /**
+     * 处理 客户端渗透服务端init close 信息
+     *
+     * @return ClientHandleTcpDistributeClientPermeateServerCloseTypeAdvanced
+     */
+    @Bean
+    public ClientHandleTcpDistributeClientPermeateServerCloseTypeAdvanced clientHandleDistributeClientPermeateServerCloseTypeAdvanced( ) {
+        return new ClientHandleTcpDistributeClientPermeateServerCloseTypeAdvanced();
+    }
+    @Bean
+    public ClientHandleTcpDistributeClientPermeateServerTransferTypeAdvanced clientHandleDistributeClientPermeateServerTransferTypeAdvanced( ) {
+        return new ClientHandleTcpDistributeClientPermeateServerTransferTypeAdvanced();
+    }
+
+    @Bean
+    public ClientHandleTcpDistributeClientPermeateClientCloseTypeAdvanced clientHandleDistributeClientPermeateClientCloseTypeAdvanced() {
+        return new ClientHandleTcpDistributeClientPermeateClientCloseTypeAdvanced();
+    }
+
+    @Bean
+    public ClientHandleTcpDistributeClientPermeateClientInitTypeAdvanced clientHandleDistributeClientPermeateClientInitTypeAdvanced() {
+        return new ClientHandleTcpDistributeClientPermeateClientInitTypeAdvanced();
+    }
+
+    @Bean
+    public ClientHandleTcpDistributeClientPermeateClientTransferCloseTypeAdvanced clientHandleDistributeClientPermeateClientTransferCloseTypeAdvanced() {
+        return new ClientHandleTcpDistributeClientPermeateClientTransferCloseTypeAdvanced();
+    }
+
+
+    @Bean
+    public ClientHandleTcpDistributeServicePermeateClientRealConnectTypeAdvanced clientHandleDistributeSingleClientRealConnectTypeAdvanced(NettyClientProperties nettyClientProperties,
+                                                                                                                                           List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList) {
+        return new ClientHandleTcpDistributeServicePermeateClientRealConnectTypeAdvanced(nettyClientProperties, handleChannelTypeAdvancedList);
+    }
+
+    @Bean
+    public ClientHandleHandleTcpDistributeClientPermeateServerTransferCloseTypeAdvanced clientHandleHandleDistributeClientPermeateServerTransferCloseTypeAdvanced() {
+        return new ClientHandleHandleTcpDistributeClientPermeateServerTransferCloseTypeAdvanced();
+    }
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/config/InitConfig.java

@@ -0,0 +1,91 @@
+package org.framework.lazy.cloud.network.heartbeat.client.config;
+
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.client.infrastructure.entity.LazyNettyServerPropertiesDO;
+import org.framework.lazy.cloud.network.heartbeat.client.application.LazyNettyServerPropertiesApplication;
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Role;
+import org.wu.framework.lazy.orm.database.lambda.stream.lambda.LazyLambdaStream;
+import org.wu.framework.lazy.orm.database.lambda.stream.wrapper.LazyWrappers;
+
+import java.util.Objects;
+
+/**
+ * 初始化配置
+ */
+@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
+@Slf4j
+@Configuration
+public class InitConfig implements CommandLineRunner, DisposableBean {
+
+    private final NettyClientProperties nettyClientProperties;
+    private final LazyLambdaStream lazyLambdaStream;
+
+    private final LazyNettyServerPropertiesApplication lazyNettyServerPropertiesApplication;
+
+    public InitConfig(NettyClientProperties nettyClientProperties, LazyLambdaStream lazyLambdaStream, LazyNettyServerPropertiesApplication lazyNettyServerPropertiesApplication) {
+        this.nettyClientProperties = nettyClientProperties;
+        this.lazyLambdaStream = lazyLambdaStream;
+        this.lazyNettyServerPropertiesApplication = lazyNettyServerPropertiesApplication;
+    }
+
+
+    @Override
+    public void run(String... args) throws Exception {
+        try {
+            // 存储配置到db
+            initDb2Config();
+            // 启动客户端连接
+            lazyNettyServerPropertiesApplication.starterAllClientSocket();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+
+    /**
+     * 存储配置到db
+     */
+    public void initDb2Config() {
+
+        String clientId = nettyClientProperties.getClientId();
+        String inetHost = nettyClientProperties.getInetHost();
+        int inetPort = nettyClientProperties.getInetPort();
+        String appKey = nettyClientProperties.getAppKey();
+        String appSecret = nettyClientProperties.getAppSecret();
+        if (Objects.isNull(clientId) ||
+                Objects.isNull(inetHost)) {
+            log.warn("配置信息为空，请通过页面添加配置信息:{}", nettyClientProperties);
+            return;
+        }
+        LazyNettyServerPropertiesDO lazyNettyServerPropertiesDO = new LazyNettyServerPropertiesDO();
+        lazyNettyServerPropertiesDO.setClientId(clientId);
+        lazyNettyServerPropertiesDO.setInetHost(inetHost);
+        lazyNettyServerPropertiesDO.setInetPort(inetPort);
+        lazyNettyServerPropertiesDO.setType(PropertiesType.CONFIG);
+        lazyNettyServerPropertiesDO.setIsDeleted(false);
+        lazyNettyServerPropertiesDO.setAppKey(appKey);
+        lazyNettyServerPropertiesDO.setAppSecret(appSecret);
+
+        // 根据服务端端口、port 唯一性验证
+        boolean exists = lazyLambdaStream.exists(LazyWrappers.<LazyNettyServerPropertiesDO>lambdaWrapper()
+                .eq(LazyNettyServerPropertiesDO::getInetHost, inetHost)
+                .eq(LazyNettyServerPropertiesDO::getInetPort, inetPort)
+                .eq(LazyNettyServerPropertiesDO::getClientId, clientId)
+        );
+        if (!exists) {
+            lazyLambdaStream.insert(lazyNettyServerPropertiesDO);
+        }
+    }
+
+    /**
+     * 程序关闭后执行
+     */
+    @Override
+    public void destroy() {
+        lazyNettyServerPropertiesApplication.destroyClientSocket();
+    }
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/config/NettyClientProperties.java

@@ -1,10 +1,9 @@
 package org.framework.lazy.cloud.network.heartbeat.client.config;
 
+import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.ProtocolType;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.context.annotation.Configuration;
-import org.wu.framework.core.NormalUsedString;
 
 /**
  * netty 客户服务端地址配置属性
@@ -14,7 +13,6 @@ import org.wu.framework.core.NormalUsedString;
 @Data
 public class NettyClientProperties {
     public static final String PREFIX = "spring.lazy.netty.client";
-
     /**
      * 服务端地址 如：127.0.0.1
      */
@@ -32,10 +30,7 @@ public class NettyClientProperties {
      */
     private String clientId;
 
-    /**
-     * 协议类型
-     */
-    private ProtocolType protocolType = ProtocolType.TCP;
+
     /**
      *
      * 令牌key

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/context/NettyClientSocketApplicationListener.java

@@ -1,107 +0,0 @@
-package org.framework.lazy.cloud.network.heartbeat.client.context;
-
-import jakarta.annotation.PreDestroy;
-import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.client.application.LazyNettyServerPropertiesApplication;
-import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
-import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
-import org.framework.lazy.cloud.network.heartbeat.client.infrastructure.entity.LazyNettyServerPropertiesDO;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.ProtocolType;
-import org.springframework.beans.factory.DisposableBean;
-import org.springframework.boot.context.event.ApplicationStartedEvent;
-import org.springframework.context.ApplicationListener;
-import org.springframework.stereotype.Component;
-import org.wu.framework.lazy.orm.database.lambda.stream.lambda.LazyLambdaStream;
-import org.wu.framework.lazy.orm.database.lambda.stream.wrapper.LazyWrappers;
-
-import java.util.Objects;
-
-@Slf4j
-@Component
-public class NettyClientSocketApplicationListener implements ApplicationListener<ApplicationStartedEvent>, DisposableBean {
-
-
-    private final NettyClientProperties nettyClientProperties;
-    private final LazyLambdaStream lazyLambdaStream;
-
-    private final LazyNettyServerPropertiesApplication lazyNettyServerPropertiesApplication;
-
-    public NettyClientSocketApplicationListener(NettyClientProperties nettyClientProperties,
-                                                LazyLambdaStream lazyLambdaStream,
-                                                LazyNettyServerPropertiesApplication lazyNettyServerPropertiesApplication) {
-        this.nettyClientProperties = nettyClientProperties;
-        this.lazyLambdaStream = lazyLambdaStream;
-        this.lazyNettyServerPropertiesApplication = lazyNettyServerPropertiesApplication;
-    }
-
-    /**
-     * 存储配置到db
-     */
-    public void initDb2Config() {
-
-      try {
-          String clientId = nettyClientProperties.getClientId();
-          String inetHost = nettyClientProperties.getInetHost();
-          int inetPort = nettyClientProperties.getInetPort();
-          String appKey = nettyClientProperties.getAppKey();
-          String appSecret = nettyClientProperties.getAppSecret();
-          ProtocolType protocolType = nettyClientProperties.getProtocolType();
-          if (Objects.isNull(clientId) ||
-                  Objects.isNull(inetHost)) {
-              log.warn("配置信息为空，请通过页面添加配置信息:{}", nettyClientProperties);
-              return;
-          }
-          LazyNettyServerPropertiesDO lazyNettyServerPropertiesDO = new LazyNettyServerPropertiesDO();
-
-          lazyNettyServerPropertiesDO.setClientId(clientId);
-          lazyNettyServerPropertiesDO.setInetHost(inetHost);
-          lazyNettyServerPropertiesDO.setInetPort(inetPort);
-          lazyNettyServerPropertiesDO.setType(PropertiesType.CONFIG);
-          lazyNettyServerPropertiesDO.setIsDeleted(false);
-          lazyNettyServerPropertiesDO.setAppKey(appKey);
-          lazyNettyServerPropertiesDO.setAppSecret(appSecret);
-          lazyNettyServerPropertiesDO.setProtocolType(protocolType);
-
-
-          // 根据服务端端口、port 唯一性验证
-          boolean exists = lazyLambdaStream.exists(LazyWrappers.<LazyNettyServerPropertiesDO>lambdaWrapper()
-                  .eq(LazyNettyServerPropertiesDO::getInetHost, inetHost)
-                  .eq(LazyNettyServerPropertiesDO::getInetPort, inetPort)
-                  .eq(LazyNettyServerPropertiesDO::getClientId, clientId)
-                  .eq(LazyNettyServerPropertiesDO::getProtocolType, protocolType)
-          );
-          if (!exists) {
-              lazyLambdaStream.insert(lazyNettyServerPropertiesDO);
-          }
-      }catch (Exception e){
-          e.printStackTrace();
-      }
-    }
-
-
-
-    /**
-     * Handle an application event.
-     *
-     * @param event the event to respond to
-     */
-    @Override
-    public void onApplicationEvent(ApplicationStartedEvent event) {
-        try {
-            // 存储配置到db
-            initDb2Config();
-            // 启动客户端连接
-            lazyNettyServerPropertiesApplication.starterAllClientSocket();
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-
-    @PreDestroy
-    @Override
-    public void destroy() throws Exception {
-        lazyNettyServerPropertiesApplication.destroyClientSocket();
-    }
-
-}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/domain/model/lazy/netty/server/properties/LazyNettyServerProperties.java

@@ -1,14 +1,15 @@
 package org.framework.lazy.cloud.network.heartbeat.client.domain.model.lazy.netty.server.properties;
 
-import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import lombok.experimental.Accessors;
-import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
+import io.swagger.v3.oas.annotations.media.Schema;
 import org.framework.lazy.cloud.network.heartbeat.common.enums.NettyClientStatus;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.ProtocolType;
-import org.wu.framework.core.NormalUsedString;
+import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
+import org.wu.framework.lazy.orm.core.stereotype.LazyTableField;
 
+import java.lang.String;
 import java.time.LocalDateTime;
+import java.lang.Integer;
 /**
  * describe 服务端配置信息 
  *
@@ -22,7 +23,6 @@ import java.time.LocalDateTime;
 public class LazyNettyServerProperties {
 
 
-
     /**
      * 
      * 客户身份ID
@@ -66,12 +66,6 @@ public class LazyNettyServerProperties {
      */
     @Schema(description ="类型（配置、DB）",name ="type",example = "")
     private PropertiesType type;
-
-    /**
-     * 协议类型
-     */
-    @Schema(description = "协议类型", name = "protocol_type", example = "")
-    private ProtocolType protocolType;
     /**
      * 令牌key
      */

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/infrastructure/converter/LazyNettyServerPropertiesConverter.java

@@ -2,46 +2,47 @@ package org.framework.lazy.cloud.network.heartbeat.client.infrastructure.convert
 
 import org.framework.lazy.cloud.network.heartbeat.client.domain.model.lazy.netty.server.properties.LazyNettyServerProperties;
 import org.framework.lazy.cloud.network.heartbeat.client.infrastructure.entity.LazyNettyServerPropertiesDO;
-import org.wu.framework.core.mapper.LazyStructMapper;
-import org.wu.framework.core.mapper.LazyStructMappers;
-
+import org.mapstruct.factory.Mappers;
+import org.mapstruct.Mapper;
 /**
- * describe 服务端配置信息
+ * describe 服务端配置信息 
  *
  * @author Jia wei Wu
  * @date 2024/04/03 03:00 下午
- * @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyInfrastructureConverter
+ * @see org.wu.framework.lazy.orm.core.persistence.reverse.lazy.ddd.DefaultDDDLazyInfrastructureConverter 
  **/
-@LazyStructMapper
+@Mapper
 public interface LazyNettyServerPropertiesConverter {
 
 
     /**
      * describe MapStruct 创建的代理对象
      *
+     
+     
+     
      * @author Jia wei Wu
      * @date 2024/04/03 03:00 下午
      **/
-    LazyNettyServerPropertiesConverter INSTANCE = LazyStructMappers.getMapper(LazyNettyServerPropertiesConverter.class);
-//    LazyNettyServerPropertiesConverter INSTANCE = new LazyNettyServerPropertiesConverterImpl();
-
+    LazyNettyServerPropertiesConverter INSTANCE = Mappers.getMapper(LazyNettyServerPropertiesConverter.class);
     /**
      * describe 实体对象 转换成领域对象
      *
-     * @param lazyNettyServerPropertiesDO 服务端配置信息实体对象
+     * @param lazyNettyServerPropertiesDO 服务端配置信息实体对象     
      * @return {@link LazyNettyServerProperties} 服务端配置信息领域对象
+     
      * @author Jia wei Wu
      * @date 2024/04/03 03:00 下午
      **/
     LazyNettyServerProperties toLazyNettyServerProperties(LazyNettyServerPropertiesDO lazyNettyServerPropertiesDO);
-
     /**
      * describe 领域对象 转换成实体对象
      *
-     * @param lazyNettyServerProperties 服务端配置信息领域对象
-     * @return {@link LazyNettyServerPropertiesDO} 服务端配置信息实体对象
+     * @param lazyNettyServerProperties 服务端配置信息领域对象     
+     * @return {@link LazyNettyServerPropertiesDO} 服务端配置信息实体对象     
+     
      * @author Jia wei Wu
      * @date 2024/04/03 03:00 下午
      **/
-    LazyNettyServerPropertiesDO fromLazyNettyServerProperties(LazyNettyServerProperties lazyNettyServerProperties);
+     LazyNettyServerPropertiesDO fromLazyNettyServerProperties(LazyNettyServerProperties lazyNettyServerProperties); 
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/infrastructure/entity/LazyNettyServerPropertiesDO.java

@@ -5,11 +5,8 @@ import lombok.Data;
 import lombok.experimental.Accessors;
 import org.framework.lazy.cloud.network.heartbeat.client.config.PropertiesType;
 import org.framework.lazy.cloud.network.heartbeat.common.enums.NettyClientStatus;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.ProtocolType;
-import org.wu.framework.core.NormalUsedString;
 import org.wu.framework.lazy.orm.core.stereotype.LazyTable;
 import org.wu.framework.lazy.orm.core.stereotype.LazyTableField;
-import org.wu.framework.lazy.orm.core.stereotype.LazyTableFieldId;
 import org.wu.framework.lazy.orm.core.stereotype.LazyTableFieldUnique;
 
 import java.time.LocalDateTime;
@@ -27,20 +24,12 @@ import java.time.LocalDateTime;
 public class LazyNettyServerPropertiesDO {
 
 
-
-    /**
-     *
-     * 主键ID
-     */
-    @Schema(description ="主键ID",name ="id",example = "")
-    @LazyTableFieldId(name = "id", comment = "主键ID")
-    private Long id;
     /**
      * 
      * 客户身份ID
      */
     @Schema(description ="客户身份ID",name ="clientId",example = "")
-    @LazyTableFieldUnique(name="client_id",comment="客户身份ID",columnType="varchar(25)")
+    @LazyTableFieldUnique(name="client_id",comment="客户身份ID",columnType="varchar(255)")
     private String clientId;
 
     /**
@@ -65,7 +54,7 @@ public class LazyNettyServerPropertiesDO {
      * 服务端host
      */
     @Schema(description ="服务端host",name ="inetHost",example = "")
-    @LazyTableFieldUnique(name="inet_host",comment="服务端host",columnType="varchar(25)")
+    @LazyTableFieldUnique(name="inet_host",comment="服务端host",columnType="varchar(255)")
     private String inetHost;
 
     /**
@@ -106,13 +95,6 @@ public class LazyNettyServerPropertiesDO {
     @LazyTableField(name="type",comment="类型（配置、DB）",columnType="varchar(255)")
     private PropertiesType type;
 
-    /**
-     * 协议类型
-     */
-    @Schema(description ="协议类型",name ="protocol_type",example = "")
-    @LazyTableField(name="protocol_type",comment="协议类型",columnType="varchar(255)")
-    private ProtocolType protocolType;
-
     /**
      * 
      * 更新时间

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/infrastructure/persistence/LazyNettyServerPropertiesRepositoryImpl.java

@@ -1,19 +1,22 @@
 package org.framework.lazy.cloud.network.heartbeat.client.infrastructure.persistence;
 
-import jakarta.annotation.Resource;
 import org.framework.lazy.cloud.network.heartbeat.client.domain.model.lazy.netty.server.properties.LazyNettyServerProperties;
 import org.framework.lazy.cloud.network.heartbeat.client.domain.model.lazy.netty.server.properties.LazyNettyServerPropertiesRepository;
-import org.framework.lazy.cloud.network.heartbeat.client.infrastructure.converter.LazyNettyServerPropertiesConverter;
 import org.framework.lazy.cloud.network.heartbeat.client.infrastructure.entity.LazyNettyServerPropertiesDO;
+import org.framework.lazy.cloud.network.heartbeat.client.infrastructure.converter.LazyNettyServerPropertiesConverter;
 import org.springframework.stereotype.Repository;
-import org.wu.framework.lazy.orm.database.lambda.domain.LazyPage;
-import org.wu.framework.lazy.orm.database.lambda.stream.lambda.LazyLambdaStream;
+
+import java.util.stream.Collectors;
+
 import org.wu.framework.lazy.orm.database.lambda.stream.wrapper.LazyWrappers;
 import org.wu.framework.web.response.Result;
 import org.wu.framework.web.response.ResultFactory;
+import jakarta.annotation.Resource;
+import org.wu.framework.lazy.orm.database.lambda.stream.lambda.LazyLambdaStream;
 
 import java.util.List;
-import java.util.stream.Collectors;
+
+import org.wu.framework.lazy.orm.database.lambda.domain.LazyPage;
 
 /**
  * describe 服务端配置信息

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/InternalNetworkClientPermeateClientVisitor.java

@@ -1,4 +1,4 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate;
+package org.framework.lazy.cloud.network.heartbeat.client.netty;
 
 import lombok.Data;
 import lombok.NoArgsConstructor;
@@ -11,17 +11,16 @@ import java.util.List;
 
 @NoArgsConstructor
 @Data
-public class NettyClientPermeateClientVisitor implements InternalNetworkPermeate {
-
+public class InternalNetworkClientPermeateClientVisitor implements InternalNetworkPermeate {
 
     /**
      * 当前客户端ID
      */
-    private String originClientId;
+    private String fromClientId;
     /**
      * 目标客户端ID
      */
-    private String targetClientId;
+    private String toClientId;
     /**
      * 目标地址
      */

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/InternalNetworkClientPermeateServerVisitor.java

@@ -1,4 +1,4 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate;
+package org.framework.lazy.cloud.network.heartbeat.client.netty;
 
 import lombok.Data;
 import lombok.NoArgsConstructor;
@@ -10,7 +10,7 @@ import java.util.List;
 
 @NoArgsConstructor
 @Data
-public class NettyClientPermeateServerVisitor implements InternalNetworkPermeate {
+public class InternalNetworkClientPermeateServerVisitor implements InternalNetworkPermeate {
 
     /**
      * 目标地址

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleChannelTransferTypeAdvancedHandleDistributeTcpDistribute.java

@@ -1,48 +1,43 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.udp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
 
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
 import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.udp.client.AbstractHandleUdpDistributeServicePermeateClientTransferTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.UdpMessageTypeEnums;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeServicePermeateClientTransferTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
 
 
 /**
  * 服务端处理客户端数据传输
  *
- * @see UdpMessageTypeEnums#UDP_DISTRIBUTE_CLIENT_TRANSFER
+ * @see MessageTypeEnums#TCP_DISTRIBUTE_CLIENT_TRANSFER
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
-public class ClientHandleUdpChannelTransferTypeAdvancedHandleDistribute extends AbstractHandleUdpDistributeServicePermeateClientTransferTypeAdvanced<NettyProxyMsg> {
+public class ClientHandleChannelTransferTypeAdvancedHandleDistributeTcpDistribute extends AbstractHandleTcpDistributeServicePermeateClientTransferTypeAdvanced<NettyProxyMsg> {
 
     private final NettyClientProperties nettyClientProperties;
 
-    public ClientHandleUdpChannelTransferTypeAdvancedHandleDistribute(NettyClientProperties nettyClientProperties) {
+    public ClientHandleChannelTransferTypeAdvancedHandleDistributeTcpDistribute(NettyClientProperties nettyClientProperties) {
         this.nettyClientProperties = nettyClientProperties;
     }
 
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
-        Channel channel = nettyChannelContext.channel();
+    public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         log.debug("接收到服务端需要内网穿透的数据:{}" , nettyProxyMsg);
         String clientId = nettyClientProperties.getClientId();
         byte[] visitorPort = nettyProxyMsg.getVisitorPort();
-        byte[] clientTargetIp = nettyProxyMsg.getTargetIp();
-        byte[] clientTargetPort = nettyProxyMsg.getTargetPort();
+        byte[] clientTargetIp = nettyProxyMsg.getClientTargetIp();
+        byte[] clientTargetPort = nettyProxyMsg.getClientTargetPort();
         byte[] visitorId = nettyProxyMsg.getVisitorId();
         // 真实服务通道
 //        Channel realChannel = NettyRealIdContext.getReal(new String(visitorId));

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleHandleTcpDistributeClientPermeateServerTransferCloseTypeAdvanced.java

@@ -0,0 +1,34 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
+
+
+import io.netty.channel.Channel;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeClientPermeateServerTransferCloseTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
+
+
+/**
+ * 下发 客户端渗透服务端通信通道关闭
+ *
+ * @see MessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE
+ */
+@Slf4j
+public class ClientHandleHandleTcpDistributeClientPermeateServerTransferCloseTypeAdvanced extends AbstractHandleTcpDistributeClientPermeateServerTransferCloseTypeAdvanced<NettyProxyMsg> {
+
+    /**
+     * 处理当前数据
+     *
+     * @param channel       当前通道
+     * @param nettyProxyMsg 通道数据
+     */
+    @Override
+    public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
+        //  关闭本地通信通道
+        Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel);
+        channel.close();
+        nextChannel.close();
+    }
+
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeClientPermeateClientCloseTypeAdvanced.java

@@ -1,23 +1,20 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
 
+import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyVisitorPortContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeClientPermeateClientCloseTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeClientPermeateClientCloseTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
 import org.framework.lazy.cloud.network.heartbeat.common.socket.PermeateVisitorSocket;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
 
 
 /**
  * 客户端渗透客户端init close 信息
  *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_CLIENT_CLOSE
+ * @see MessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_CLIENT_CLOSE
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
 public class ClientHandleTcpDistributeClientPermeateClientCloseTypeAdvanced extends AbstractHandleTcpDistributeClientPermeateClientCloseTypeAdvanced<NettyProxyMsg> {
 
@@ -25,11 +22,11 @@ public class ClientHandleTcpDistributeClientPermeateClientCloseTypeAdvanced exte
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
+    public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         // 初始化 客户端渗透服务端socket
         byte[] msgVisitorPort = nettyProxyMsg.getVisitorPort();
         Integer visitorPort = Integer.parseInt(new String(msgVisitorPort));

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeClientPermeateClientInitTypeAdvanced.java

@@ -1,16 +1,14 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.udp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
 
+import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
 import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.udp.socket.NettyUdpClientPermeateClientVisitorSocket;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientPermeateClientVisitorSocket;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.udp.client.AbstractHandleUdpDistributeClientPermeateClientInitTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeClientPermeateClientInitTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
 import org.wu.framework.spring.utils.SpringContextHolder;
 
 import java.util.ArrayList;
@@ -20,29 +18,28 @@ import java.util.List;
 /**
  * 客户端渗透客户端init信息
  *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_CLIENT_INIT
+ * @see MessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_CLIENT_INIT
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
-public class ClientHandleUdpDistributeClientPermeateClientInitTypeAdvanced extends AbstractHandleUdpDistributeClientPermeateClientInitTypeAdvanced<NettyProxyMsg> {
+public class ClientHandleTcpDistributeClientPermeateClientInitTypeAdvanced extends AbstractHandleTcpDistributeClientPermeateClientInitTypeAdvanced<NettyProxyMsg> {
 
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
+    public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         // 初始化 客户端渗透服务端socket
-        byte[] originClientIdBytes = nettyProxyMsg.getClientId();
+        byte[] fromClientIdBytes = nettyProxyMsg.getClientId();
         byte[] visitorPortBytes = nettyProxyMsg.getVisitorPort();
-        byte[] clientTargetIpBytes = nettyProxyMsg.getTargetIp();
-        byte[] clientTargetPortBytes = nettyProxyMsg.getTargetPort();
-        byte[] targetClientIdBytes = nettyProxyMsg.getData();
+        byte[] clientTargetIpBytes = nettyProxyMsg.getClientTargetIp();
+        byte[] clientTargetPortBytes = nettyProxyMsg.getClientTargetPort();
+        byte[] toClientIdBytes = nettyProxyMsg.getData();
 
-        String originClientId = new String(originClientIdBytes);
-        String targetClientId = new String(targetClientIdBytes);
+        String fromClientId = new String(fromClientIdBytes);
+        String toClientId = new String(toClientIdBytes);
         Integer visitorPort = Integer.parseInt(new String(visitorPortBytes));
         String clientTargetIp = new String(clientTargetIpBytes);
         Integer clientTargetPort = Integer.parseInt(new String(clientTargetPortBytes));
@@ -50,22 +47,22 @@ public class ClientHandleUdpDistributeClientPermeateClientInitTypeAdvanced exten
         List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList = new ArrayList<>(SpringContextHolder.getApplicationContext().getBeansOfType(HandleChannelTypeAdvanced.class).values());
 //        ChannelFlowAdapter channelFlowAdapter = SpringContextHolder.getBean(ChannelFlowAdapter.class);
         NettyClientProperties nettyClientProperties = SpringContextHolder.getBean(NettyClientProperties.class);
-        log.info("client permeate client from client_id:【{}】 target_client_id【{}】with visitor_port【{}】, clientTargetIp:【{}】clientTargetPort:【{}】",
-                originClientId, targetClientId, visitorPort, clientTargetIp, clientTargetPort);
-        NettyUdpClientPermeateClientVisitorSocket nettyTcpClientPermeateClientVisitorSocket =
-                NettyUdpClientPermeateClientVisitorSocket.NettyClientPermeateClientVisitorSocketBuilder.builder()
-                        .builderClientId(originClientId)
+        log.info("client permeate client from client_id:【{}】 to_client_id【{}】with visitor_port【{}】, clientTargetIp:【{}】clientTargetPort:【{}】",
+                fromClientId, toClientId, visitorPort, clientTargetIp, clientTargetPort);
+        NettyClientPermeateClientVisitorSocket nettyClientPermeateClientVisitorSocket =
+                NettyClientPermeateClientVisitorSocket.NettyClientPermeateClientVisitorSocketBuilder.builder()
+                        .builderClientId(fromClientId)
                         .builderClientTargetIp(clientTargetIp)
                         .builderClientTargetPort(clientTargetPort)
                         .builderVisitorPort(visitorPort)
                 .builderNettyClientProperties(nettyClientProperties)
 //                .builderChannelFlowAdapter(channelFlowAdapter)
-                        .builderToClientId(targetClientId)
+                        .builderToClientId(toClientId)
                 .builderHandleChannelTypeAdvancedList(handleChannelTypeAdvancedList)
 
                 .build();
         try {
-            nettyTcpClientPermeateClientVisitorSocket.start();
+            nettyClientPermeateClientVisitorSocket.start();
         } catch (Exception e) {
             e.printStackTrace();
         }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeClientPermeateClientTransferCloseTypeAdvanced.java

@@ -1,35 +1,30 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
 
 import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeClientPermeateClientTransferCloseTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeClientPermeateClientTransferCloseTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
 
 
 /**
  * 下发客户端渗透客户端通信通道关闭
  *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE
+ * @see MessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
 public class ClientHandleTcpDistributeClientPermeateClientTransferCloseTypeAdvanced extends AbstractHandleTcpDistributeClientPermeateClientTransferCloseTypeAdvanced<NettyProxyMsg> {
 
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
-        Channel channel = nettyChannelContext.channel();
+    public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         // 关闭客户端真实通道、访客通道
         Channel realChannel = ChannelAttributeKeyUtils.getNextChannel(channel);
         realChannel.close();// 真实通道关闭

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeClientPermeateServerCloseTypeAdvanced.java

@@ -1,23 +1,20 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
 
+import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyVisitorPortContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeClientPermeateServerCloseTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeClientPermeateServerCloseTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
 import org.framework.lazy.cloud.network.heartbeat.common.socket.PermeateVisitorSocket;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
 
 
 /**
  * 客户端渗透服务端init close 信息
  *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_SERVER_CLOSE
+ * @see MessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_SERVER_CLOSE
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
 public class ClientHandleTcpDistributeClientPermeateServerCloseTypeAdvanced extends AbstractHandleTcpDistributeClientPermeateServerCloseTypeAdvanced<NettyProxyMsg> {
 
@@ -25,11 +22,11 @@ public class ClientHandleTcpDistributeClientPermeateServerCloseTypeAdvanced exte
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
+    public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         // 初始化 客户端渗透服务端socket
         byte[] msgVisitorPort = nettyProxyMsg.getVisitorPort();
         Integer visitorPort = Integer.parseInt(new String(msgVisitorPort));

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeClientPermeateServerInitTypeAdvanced.java

@@ -1,16 +1,14 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
 
+import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
 import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.socket.NettyTcpClientPermeateServerVisitorSocket;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientPermeateServerVisitorSocket;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeClientPermeateServerInitTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeClientPermeateServerInitTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
 import org.wu.framework.spring.utils.SpringContextHolder;
 
 import java.util.ArrayList;
@@ -20,9 +18,8 @@ import java.util.List;
 /**
  * 客户端渗透服务端init信息
  *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_SERVER_INIT
+ * @see MessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_SERVER_INIT
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
 public class ClientHandleTcpDistributeClientPermeateServerInitTypeAdvanced extends AbstractHandleTcpDistributeClientPermeateServerInitTypeAdvanced<NettyProxyMsg> {
 
@@ -35,19 +32,19 @@ public class ClientHandleTcpDistributeClientPermeateServerInitTypeAdvanced exten
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
+    public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         // 初始化 客户端渗透服务端socket
         byte[] clientIdBytes = nettyProxyMsg.getClientId();
         byte[] visitorPort = nettyProxyMsg.getVisitorPort();
-        byte[] clientTargetIp = nettyProxyMsg.getTargetIp();
-        byte[] clientTargetPort = nettyProxyMsg.getTargetPort();
+        byte[] clientTargetIp = nettyProxyMsg.getClientTargetIp();
+        byte[] clientTargetPort = nettyProxyMsg.getClientTargetPort();
 
         List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList = new ArrayList<>(SpringContextHolder.getApplicationContext().getBeansOfType(HandleChannelTypeAdvanced.class).values());
-        NettyTcpClientPermeateServerVisitorSocket nettyTcpClientPermeateServerVisitorSocket = NettyTcpClientPermeateServerVisitorSocket.NettyVisitorSocketBuilder.builder()
+        NettyClientPermeateServerVisitorSocket nettyClientPermeateServerVisitorSocket = NettyClientPermeateServerVisitorSocket.NettyVisitorSocketBuilder.builder()
                 .builderClientId(new String(clientIdBytes))
                 .builderClientTargetIp(new String(clientTargetIp))
                 .builderClientTargetPort(Integer.parseInt(new String(clientTargetPort)))
@@ -56,7 +53,7 @@ public class ClientHandleTcpDistributeClientPermeateServerInitTypeAdvanced exten
                 .builderHandleChannelTypeAdvancedList(handleChannelTypeAdvancedList)
                 .build();
         try {
-            nettyTcpClientPermeateServerVisitorSocket.start();
+            nettyClientPermeateServerVisitorSocket.start();
         } catch (Exception e) {
             log.error(e.getMessage(), e);
             e.printStackTrace();

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeClientPermeateServerTransferTypeAdvanced.java

@@ -1,24 +1,20 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
 
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeClientPermeateServerTransferTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeClientPermeateServerTransferTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
 
 
 /**
  * 服务端处理客户端数据传输
  *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_TRANSFER
+ * @see MessageTypeEnums#TCP_DISTRIBUTE_CLIENT_TRANSFER
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
 public class ClientHandleTcpDistributeClientPermeateServerTransferTypeAdvanced extends AbstractHandleTcpDistributeClientPermeateServerTransferTypeAdvanced<NettyProxyMsg> {
 
@@ -26,16 +22,15 @@ public class ClientHandleTcpDistributeClientPermeateServerTransferTypeAdvanced e
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
-        Channel channel = nettyChannelContext.channel();
+    public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         log.debug("客户端渗透服务端返回数据:{}" , new String(nettyProxyMsg.getData()));
         byte[] visitorPort = nettyProxyMsg.getVisitorPort();
-        byte[] clientTargetIp = nettyProxyMsg.getTargetIp();
-        byte[] clientTargetPort = nettyProxyMsg.getTargetPort();
+        byte[] clientTargetIp = nettyProxyMsg.getClientTargetIp();
+        byte[] clientTargetPort = nettyProxyMsg.getClientTargetPort();
         byte[] visitorId = nettyProxyMsg.getVisitorId();
         // 真实服务通道
 //        Channel realChannel = NettyRealIdContext.getReal(new String(visitorId));

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced.java

@@ -1,16 +1,14 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
 
+import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
 import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.socket.NettyTcpClientPermeateClientRealSocket;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientPermeateClientRealSocket;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
 import org.wu.framework.spring.utils.SpringContextHolder;
 
 import java.util.ArrayList;
@@ -21,24 +19,23 @@ import java.util.List;
  * 客户端渗透客户端数据传输通道连接成功
  *
  *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+ * @see MessageTypeEnums#TCP_DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
 public class ClientHandleTcpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced extends AbstractHandleTcpDistributeClientTransferClientPermeateChannelConnectionSuccessfulTypeAdvanced<NettyProxyMsg> {
 
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
+    public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         // 创建connect 然后发送创建成功
         byte[] msgClientId = nettyProxyMsg.getClientId();
-        byte[] msgClientTargetIp = nettyProxyMsg.getTargetIp();
-        byte[] msgClientTargetPort = nettyProxyMsg.getTargetPort();
+        byte[] msgClientTargetIp = nettyProxyMsg.getClientTargetIp();
+        byte[] msgClientTargetPort = nettyProxyMsg.getClientTargetPort();
         byte[] msgVisitorId = nettyProxyMsg.getVisitorId();
         byte[] msgVisitorPort = nettyProxyMsg.getVisitorPort();
 
@@ -49,7 +46,7 @@ public class ClientHandleTcpDistributeClientTransferClientPermeateChannelConnect
         Integer visitorPort=Integer.parseInt(new String(msgVisitorPort));
         NettyClientProperties nettyClientProperties = SpringContextHolder.getBean(NettyClientProperties.class);
         List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList = new ArrayList<>(SpringContextHolder.getApplicationContext().getBeansOfType(HandleChannelTypeAdvanced.class).values());
-        NettyTcpClientPermeateClientRealSocket.buildRealServer(
+        NettyClientPermeateClientRealSocket.buildRealServer(
                 clientId,
                 clientTargetIp,
                 clientTargetPort,

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced.java

@@ -1,25 +1,21 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelOption;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
 
 
 /**
  * 下发 客户端渗透客户端数据传输通道init 成功
  *
  *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+ * @see MessageTypeEnums#TCP_DISTRIBUTE_CLIENT_TRANSFER_CLIENT_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
 public class ClientHandleTcpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced extends AbstractHandleTcpDistributeClientTransferClientPermeateChannelInitSuccessfulTypeAdvanced<NettyProxyMsg> {
 
@@ -28,16 +24,15 @@ public class ClientHandleTcpDistributeClientTransferClientPermeateChannelInitSuc
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
-        Channel channel = nettyChannelContext.channel();
+    public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         // 连接成功 开启自动读取写
         byte[] msgClientId = nettyProxyMsg.getClientId();
-        byte[] msgClientTargetIp = nettyProxyMsg.getTargetIp();
-        byte[] msgClientTargetPort = nettyProxyMsg.getTargetPort();
+        byte[] msgClientTargetIp = nettyProxyMsg.getClientTargetIp();
+        byte[] msgClientTargetPort = nettyProxyMsg.getClientTargetPort();
         byte[] msgVisitorId = nettyProxyMsg.getVisitorId();
         byte[] msgVisitorPort = nettyProxyMsg.getVisitorPort();
 

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeClientTransferClientRequestTypeAdvanced.java

@@ -1,25 +1,21 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
 
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeClientTransferClientRequestTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeClientTransferClientRequestTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
 
 
 /**
  * 下发客户端渗透客户端数据传输
  *
  *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_REQUEST
+ * @see MessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_REQUEST
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
 public class ClientHandleTcpDistributeClientTransferClientRequestTypeAdvanced extends AbstractHandleTcpDistributeClientTransferClientRequestTypeAdvanced<NettyProxyMsg> {
 
@@ -28,12 +24,11 @@ public class ClientHandleTcpDistributeClientTransferClientRequestTypeAdvanced ex
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
-        Channel channel = nettyChannelContext.channel();
+    public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel);
         // 把数据转到真实服务
         ByteBuf buf = channel.config().getAllocator().buffer(nettyProxyMsg.getData().length);

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java

@@ -0,0 +1,43 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
+
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelOption;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientPermeateServerVisitorHandler;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientPermeateServerVisitorTransferSocket;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
+import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
+
+
+/**
+ * 客户端渗透服务端数据传输通道连接成功
+ * @see NettyClientPermeateServerVisitorTransferSocket
+ * @see NettyClientPermeateServerVisitorHandler
+ *
+ * @see MessageTypeEnums#TCP_DISTRIBUTE_CLIENT_TRANSFER_SERVER_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
+ */
+@Slf4j
+public class ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced extends AbstractHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced<NettyProxyMsg> {
+
+
+
+    /**
+     * 处理当前数据
+     *
+     * @param transferChannel       当前通道
+     * @param nettyProxyMsg 通道数据
+     */
+    @Override
+    public void doHandler(Channel transferChannel, NettyProxyMsg nettyProxyMsg) {
+        // 连接成功 开启自动读取写
+        byte[] msgVisitorId = nettyProxyMsg.getVisitorId();
+        String visitorId = new String(msgVisitorId);
+        Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(transferChannel);
+        nextChannel.config().setOption(ChannelOption.AUTO_READ, true);
+
+    }
+
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeServicePermeateClientRealConnectTypeAdvanced.java

@@ -1,48 +1,43 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
+import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
 import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.socket.NettyTcpServerPermeateClientRealSocket;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyServerPermeateClientRealSocket;
 import org.framework.lazy.cloud.network.heartbeat.common.InternalNetworkPenetrationRealClient;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeServicePermeateClientRealConnectTypeAdvanced;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
-import org.wu.framework.spring.utils.SpringContextHolder;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeServicePermeateClientRealConnectTypeAdvanced;
 
-import java.util.ArrayList;
 import java.util.List;
 
 /**
  * 客户端创建真实代理同奥
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
 public class ClientHandleTcpDistributeServicePermeateClientRealConnectTypeAdvanced extends AbstractHandleTcpDistributeServicePermeateClientRealConnectTypeAdvanced<NettyProxyMsg> {
 
     private final NettyClientProperties nettyClientProperties;// 服务端地址信息
+    private final List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList;
 
-
-    public ClientHandleTcpDistributeServicePermeateClientRealConnectTypeAdvanced(NettyClientProperties nettyClientProperties) {
+    public ClientHandleTcpDistributeServicePermeateClientRealConnectTypeAdvanced(NettyClientProperties nettyClientProperties, List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList) {
         this.nettyClientProperties = nettyClientProperties;
-
+        this.handleChannelTypeAdvancedList = handleChannelTypeAdvancedList;
     }
 
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext 当前通道
+     * @param channel 当前通道
      * @param msg     通道数据
      */
     @Override
-    protected void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg msg) {
+    protected void doHandler(Channel channel, NettyProxyMsg msg) {
         // 创建真实端口监听
         byte[] clientIdBytes = msg.getClientId();
         byte[] visitorPort = msg.getVisitorPort();
-        byte[] clientTargetIp = msg.getTargetIp();
-        byte[] clientTargetPort = msg.getTargetPort();
+        byte[] clientTargetIp = msg.getClientTargetIp();
+        byte[] clientTargetPort = msg.getClientTargetPort();
         byte[] visitorIdBytes = msg.getVisitorId();
         InternalNetworkPenetrationRealClient internalNetworkPenetrationRealClient =
                 InternalNetworkPenetrationRealClient
@@ -54,9 +49,8 @@ public class ClientHandleTcpDistributeServicePermeateClientRealConnectTypeAdvanc
                         .visitorId(new String(visitorIdBytes))
                         .build();
 
-        List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList = new ArrayList<>(SpringContextHolder.getApplicationContext().getBeansOfType(HandleChannelTypeAdvanced.class).values());
         // 绑定真实服务端口
-        NettyTcpServerPermeateClientRealSocket.buildRealServer(internalNetworkPenetrationRealClient, nettyClientProperties, handleChannelTypeAdvancedList);
+        NettyServerPermeateClientRealSocket.buildRealServer(internalNetworkPenetrationRealClient, nettyClientProperties, handleChannelTypeAdvancedList);
 
     }
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeServicePermeateClientTransferClientResponseTypeAdvanced.java

@@ -1,25 +1,21 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
 
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeServicePermeateClientTransferClientResponseTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeServicePermeateClientTransferClientResponseTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.enums.MessageTypeEnums;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
 
 
 /**
  * 下发客户端渗透客户端数据传输响应
  *
  *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_RESPONSE
+ * @see MessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_CLIENT_TRANSFER_RESPONSE
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
 public class ClientHandleTcpDistributeServicePermeateClientTransferClientResponseTypeAdvanced extends AbstractHandleTcpDistributeServicePermeateClientTransferClientResponseTypeAdvanced<NettyProxyMsg> {
 
@@ -28,12 +24,11 @@ public class ClientHandleTcpDistributeServicePermeateClientTransferClientRespons
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
-        Channel channel = nettyChannelContext.channel();
+    public void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel);
         // 把数据转到真实服务
         ByteBuf buf = channel.config().getAllocator().buffer(nettyProxyMsg.getData().length);

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeSingleClientMessageTypeAdvanced.java

@@ -1,26 +1,23 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
+import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeSingleClientMessageTypeAdvanced;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeSingleClientMessageTypeAdvanced;
 
 /**
  * 接收服务端发送过来的聊天信息
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
 public class ClientHandleTcpDistributeSingleClientMessageTypeAdvanced extends AbstractHandleTcpDistributeSingleClientMessageTypeAdvanced<NettyProxyMsg> {
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    protected void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
+    protected void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         byte[] clientId = nettyProxyMsg.getClientId();
         byte[] data = nettyProxyMsg.getData();
         log.info("接收客户端：{},发送过来的聊天信息:{}", new String(clientId), new String(data));

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeSingleClientRealAutoReadConnectTypeAdvanced.java

@@ -1,28 +1,23 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelOption;
 import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyRealIdContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeSingleClientRealAutoReadConnectTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeSingleClientRealAutoReadConnectTypeAdvanced;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
 
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
 public class ClientHandleTcpDistributeSingleClientRealAutoReadConnectTypeAdvanced extends AbstractHandleTcpDistributeSingleClientRealAutoReadConnectTypeAdvanced<NettyProxyMsg> {
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    protected void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
-        Channel channel = nettyChannelContext.channel();
+    protected void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         // 获取访客ID
         byte[] visitorId = nettyProxyMsg.getVisitorId();
         // 获取访客对应的真实代理通道

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientHandleTcpDistributeSingleClientRealCloseVisitorTypeAdvanced.java

@@ -1,25 +1,22 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
+import io.netty.channel.Channel;
 import lombok.extern.slf4j.Slf4j;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyCommunicationIdContext;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyRealIdContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeSingleClientRealCloseVisitorTypeAdvanced;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeSingleClientRealCloseVisitorTypeAdvanced;
 
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 @Slf4j
 public class ClientHandleTcpDistributeSingleClientRealCloseVisitorTypeAdvanced extends AbstractHandleTcpDistributeSingleClientRealCloseVisitorTypeAdvanced<NettyProxyMsg> {
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    protected void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
+    protected void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         // 关闭代理的真实通道
         byte[] visitorId = nettyProxyMsg.getVisitorId();
         NettyRealIdContext.clear(visitorId);

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/ClientTcpHandleChannelHeartbeatTypeAdvanced.java

@@ -0,0 +1,29 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
+
+
+import io.netty.channel.Channel;
+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.advanced.tcp.AbstractTcpHandleChannelHeartbeatTypeAdvanced;
+
+
+/**
+ * 服务端 处理客户端心跳
+ * TCP_TYPE_HEARTBEAT
+ */
+public class ClientTcpHandleChannelHeartbeatTypeAdvanced extends AbstractTcpHandleChannelHeartbeatTypeAdvanced<NettyProxyMsg> {
+
+    /**
+     * 处理当前数据
+     *
+     * @param channel 当前通道
+     * @param msg     通道数据
+     */
+    @Override
+    public void doHandler(Channel channel, NettyProxyMsg msg) {
+        NettyProxyMsg hb = new NettyProxyMsg();
+        hb.setType(MessageType.TCP_TYPE_HEARTBEAT);
+//        channel.writeAndFlush(hb);
+    }
+
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/HandleTcpClientChannelActiveAdvanced.java

@@ -1,39 +1,33 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.udp.advanced;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
 
 import io.netty.channel.Channel;
 import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
 import org.framework.lazy.cloud.network.heartbeat.common.ChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.udp.client.AbstractHandleUdpClientChannelActiveAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpClientChannelActiveAdvanced;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
 
 /**
  * 客户端通道 is active
  */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
-public class ClientHandleUdpClientChannelActiveAdvanced extends AbstractHandleUdpClientChannelActiveAdvanced<NettyProxyMsg> {
+public class HandleTcpClientChannelActiveAdvanced extends AbstractHandleTcpClientChannelActiveAdvanced<NettyProxyMsg> {
     private final NettyClientProperties nettyClientProperties;
 
-    public ClientHandleUdpClientChannelActiveAdvanced(NettyClientProperties nettyClientProperties) {
+    public HandleTcpClientChannelActiveAdvanced(NettyClientProperties nettyClientProperties) {
         this.nettyClientProperties = nettyClientProperties;
     }
 
     /**
      * 处理当前数据
      *
-     * @param nettyChannelContext       当前通道
+     * @param channel       当前通道
      * @param nettyProxyMsg 通道数据
      */
     @Override
-    protected void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
-        Channel channel = nettyChannelContext.channel();
+    protected void doHandler(Channel channel, NettyProxyMsg nettyProxyMsg) {
         // 缓存当前通道
         byte[] clientIdByte = nettyProxyMsg.getClientId();
         String clientId = new String(clientIdByte);
-        String serverId = new String(clientIdByte);
         ChannelContext.push(channel, clientId);
         ChannelAttributeKeyUtils.buildClientId(channel, clientId);
     }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/HandleTcpDistributeConnectSuccessNotificationTypeAdvancedHandle.java

@@ -0,0 +1,44 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
+
+import com.alibaba.fastjson.JSONObject;
+import io.netty.channel.Channel;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.event.ClientChangeEvent;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeConnectSuccessNotificationTypeAdvancedHandle;
+
+import java.util.List;
+
+/**
+ * 客户端连接成功通知
+ */
+@Slf4j
+public class HandleTcpDistributeConnectSuccessNotificationTypeAdvancedHandle extends AbstractHandleTcpDistributeConnectSuccessNotificationTypeAdvancedHandle<NettyProxyMsg> {
+
+    private final ClientChangeEvent clientChangeEvent;
+
+
+    public HandleTcpDistributeConnectSuccessNotificationTypeAdvancedHandle(ClientChangeEvent clientChangeEvent) {
+        this.clientChangeEvent = clientChangeEvent;
+    }
+
+    /**
+     * 处理当前数据
+     *
+     * @param channel 当前通道
+     * @param msg     通道数据
+     */
+    @Override
+    protected void doHandler(Channel channel, NettyProxyMsg msg) {
+        // 客户端ID：{},客户端:{}连接成功
+        log.warn("Client ID: {}, Client Data : {} Connection successful", new String(msg.getClientId()), new String(msg.getData()));
+
+
+        // 存储其他客户端状态
+        List<String> clientIdList = JSONObject.parseArray(new String(msg.getData()), String.class);
+        for (String clientId : clientIdList) {
+            clientChangeEvent.clientOnLine(clientId);
+        }
+
+    }
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/HandleTcpDistributeDisconnectTypeAdvancedHandle.java

@@ -0,0 +1,43 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
+
+
+import io.netty.channel.Channel;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.event.ClientChangeEvent;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeDisconnectTypeAdvancedHandle;
+
+
+/**
+ * 服务端处理客户端断开连接处理
+ * TYPE_DISCONNECT
+ */
+@Slf4j
+public class HandleTcpDistributeDisconnectTypeAdvancedHandle extends AbstractHandleTcpDistributeDisconnectTypeAdvancedHandle<NettyProxyMsg> {
+
+
+    private final ClientChangeEvent clientChangeEvent;
+
+    public HandleTcpDistributeDisconnectTypeAdvancedHandle(ClientChangeEvent clientChangeEvent) {
+        this.clientChangeEvent = clientChangeEvent;
+    }
+
+    /**
+     * 处理当前数据
+     *
+     * @param channel 当前通道
+     * @param msg     通道数据
+     */
+    @Override
+    public void doHandler(Channel channel, NettyProxyMsg msg) {
+        // 服务下线
+        byte[] data = msg.getData();
+        byte[] clientId = msg.getClientId();
+        String tenantId = new String(clientId);
+        //客户端:{}下线
+        log.warn("Client: {} Offline", tenantId);
+        clientChangeEvent.clientOffLine(tenantId);
+
+    }
+
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/HandleTcpDistributeStagingClosedTypeAdvanced.java

@@ -0,0 +1,30 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
+
+import io.netty.channel.Channel;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeStagingClosedTypeAdvanced;
+
+/**
+ * 服务端下发暂存关闭消息处理
+ */
+@Slf4j
+public class HandleTcpDistributeStagingClosedTypeAdvanced extends AbstractHandleTcpDistributeStagingClosedTypeAdvanced<NettyProxyMsg> {
+
+
+    /**
+     * 处理当前数据
+     *
+     * @param channel 当前通道
+     * @param msg     通道数据
+     */
+    @Override
+    protected void doHandler(Channel channel, NettyProxyMsg msg) {
+        String clientId = new String(msg.getClientId());
+        log.info("客户端：{}离线暂存关闭", clientId);
+        // 修改redis 客户端暂存状态
+//        String stagingStatusKey = StagingConfigKeyConstant.getStagingStatusKey(clientId);
+//        stringRedisTemplate.opsForValue().set(stagingStatusKey, StagingStatus.CLOSED.name());
+
+    }
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/advanced/HandleTcpDistributeStagingOpenedTypeAdvanced.java

@@ -0,0 +1,34 @@
+package org.framework.lazy.cloud.network.heartbeat.client.netty.advanced;
+
+import io.netty.channel.Channel;
+import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.advanced.tcp.client.AbstractHandleTcpDistributeStagingOpenedTypeAdvanced;
+
+/**
+ * 服务端下发暂存开启消息处理
+ */
+@Slf4j
+public class HandleTcpDistributeStagingOpenedTypeAdvanced extends AbstractHandleTcpDistributeStagingOpenedTypeAdvanced<NettyProxyMsg> {
+
+
+    public HandleTcpDistributeStagingOpenedTypeAdvanced() {
+
+    }
+
+    /**
+     * 处理当前数据
+     *
+     * @param channel 当前通道
+     * @param msg     通道数据
+     */
+    @Override
+    protected void doHandler(Channel channel, NettyProxyMsg msg) {
+        String clientId = new String(msg.getClientId());
+        //客户端：{}离线暂存开启
+        log.warn("Client: {} Offline temporary storage enabled", new String(msg.getClientId()));
+        // 修改redis 客户端暂存状态
+//        String stagingStatusKey = StagingConfigKeyConstant.getStagingStatusKey(clientId);
+//        stringRedisTemplate.opsForValue().set(stagingStatusKey, StagingStatus.OPENED.name());
+    }
+}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/event/ClientChangeEvent.java

@@ -1,4 +1,4 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.event;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.event;
 
 /**
  *  客户端状态变更事件
@@ -13,12 +13,12 @@ public interface ClientChangeEvent {
 
     /**
      * 推送客户端在线
-     *
-     * @param inetHost 服务端ip
-     * @param inetPort 服务端端口
-     * @param clientId 客户端
+     * @param clientId  客户端
+     * @param inetHost  服务端ip
+     * @param inetPort  服务端端口
+     * @param serverId  服务端ID
      */
-    void clientOnLine(String inetHost, int inetPort,String clientId);
+    void clientOnLine(String inetHost, int inetPort,String serverId ,String clientId);
 
     /**
      * 推送客户端离线
@@ -30,9 +30,10 @@ public interface ClientChangeEvent {
      *
      * @param inetHost 服务端ip
      * @param inetPort 服务端端口
+     * @param serverId 服务端ID
      * @param clientId 客户端
      */
-    void clientOffLine(String inetHost, int inetPort,String clientId);
+    void clientOffLine(String inetHost, int inetPort,String serverId,String clientId);
 
     /**
      * 暂存开启

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/event/DefaultClientChangeEventImpl.java

@@ -1,4 +1,4 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.event;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.event;
 
 
 import jakarta.annotation.Resource;
@@ -51,10 +51,11 @@ public class DefaultClientChangeEventImpl implements ClientChangeEvent {
      *
      * @param inetHost 服务端ip
      * @param inetPort 服务端端口
+     * @param serverId 服务端ID
      * @param clientId 客户端
      */
     @Override
-    public void clientOnLine(String inetHost, int inetPort, String clientId) {
+    public void clientOnLine(String inetHost, int inetPort, String serverId, String clientId) {
         LazyNettyServerProperties lazyNettyServerProperties = new LazyNettyServerProperties();
         lazyNettyServerProperties.setClientId(clientId);
         lazyNettyServerProperties.setInetHost(inetHost);
@@ -91,10 +92,11 @@ public class DefaultClientChangeEventImpl implements ClientChangeEvent {
      *
      * @param inetHost 服务端ip
      * @param inetPort 服务端端口
+     * @param serverId
      * @param clientId 客户端
      */
     @Override
-    public void clientOffLine(String inetHost, int inetPort, String clientId) {
+    public void clientOffLine(String inetHost, int inetPort, String serverId, String clientId) {
         LazyNettyServerProperties lazyNettyServerProperties = new LazyNettyServerProperties();
         lazyNettyServerProperties.setClientId(clientId);
         lazyNettyServerProperties.setInetHost(inetHost);

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientFilter.java

@@ -1,26 +1,26 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.filter;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.filter;
 
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.socket.SocketChannel;
 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.client.netty.permeate.tcp.handler.NettyTcpClientHandler;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.socket.NettyTcpClientSocket;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientHandler;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientSocket;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter;
 import org.framework.lazy.cloud.network.heartbeat.common.decoder.NettyProxyMsgDecoder;
 import org.framework.lazy.cloud.network.heartbeat.common.encoder.NettyProxyMsgEncoder;
 import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer;
 
-public class NettyTcpClientFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyClientFilter extends DebugChannelInitializer<SocketChannel> {
 
 
     private final ChannelTypeAdapter channelTypeAdapter;
-    private final NettyTcpClientSocket nettyTcpClientSocket;
+    private final NettyClientSocket nettyClientSocket;
 
-    public NettyTcpClientFilter(ChannelTypeAdapter channelTypeAdapter, NettyTcpClientSocket nettyTcpClientSocket) {
+    public NettyClientFilter(ChannelTypeAdapter channelTypeAdapter, NettyClientSocket nettyClientSocket) {
         this.channelTypeAdapter = channelTypeAdapter;
-        this.nettyTcpClientSocket = nettyTcpClientSocket;
+        this.nettyClientSocket = nettyClientSocket;
     }
 
     @Override
@@ -40,6 +40,6 @@ public class NettyTcpClientFilter extends DebugChannelInitializer<SocketChannel>
         pipeline.addLast(new IdleStateHandler(0, 4, 0));
         pipeline.addLast("decoder", new StringDecoder());
         pipeline.addLast("encoder", new StringEncoder());
-        pipeline.addLast("doHandler", new NettyTcpClientHandler(channelTypeAdapter, nettyTcpClientSocket)); //客户端的逻辑
+        pipeline.addLast("doHandler", new NettyClientHandler(channelTypeAdapter, nettyClientSocket)); //客户端的逻辑
     }
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientPermeateClientRealFilter.java

@@ -1,14 +1,15 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.filter;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.filter;
 
+import io.netty.buffer.UnpooledDirectByteBuf;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.socket.SocketChannel;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler.NettyTcpClientPermeateClientRealHandler;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientPermeateClientRealHandler;
 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;
 
-public class NettyTcpClientPermeateClientRealFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyClientPermeateClientRealFilter 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}.
@@ -21,7 +22,7 @@ public class NettyTcpClientPermeateClientRealFilter extends DebugChannelInitiali
         // 解码、编码
         pipeline.addLast(new TransferDecoder(Integer.MAX_VALUE, 1024 * 1024*10));
         pipeline.addLast(new TransferEncoder());
-        pipeline.addLast(new NettyTcpClientPermeateClientRealHandler());
+        pipeline.addLast(new NettyClientPermeateClientRealHandler());
 
     }
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientPermeateClientTransferFilter.java

@@ -1,11 +1,11 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.udp.filter;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.filter;
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.socket.SocketChannel;
 import io.netty.handler.timeout.IdleStateHandler;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.udp.handler.NettyUdpClientPermeateClientTransferHandler;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientPermeateClientTransferHandler;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter;
 import org.framework.lazy.cloud.network.heartbeat.common.decoder.NettyProxyMsgDecoder;
 import org.framework.lazy.cloud.network.heartbeat.common.encoder.NettyProxyMsgEncoder;
@@ -14,10 +14,10 @@ import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInit
 /**
  * netty 客户端渗透通信通道
  */
-public class NettyUdpClientPermeateClientTransferFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyClientPermeateClientTransferFilter extends DebugChannelInitializer<SocketChannel> {
     private final ChannelTypeAdapter channelTypeAdapter;
 
-    public NettyUdpClientPermeateClientTransferFilter(ChannelTypeAdapter channelTypeAdapter) {
+    public NettyClientPermeateClientTransferFilter(ChannelTypeAdapter channelTypeAdapter) {
         this.channelTypeAdapter = channelTypeAdapter;
     }
 
@@ -41,6 +41,6 @@ public class NettyUdpClientPermeateClientTransferFilter extends DebugChannelInit
 
         pipeline.addLast(new NettyProxyMsgDecoder(Integer.MAX_VALUE, 0, 4, -4, 0));
         pipeline.addLast(new NettyProxyMsgEncoder());
-        pipeline.addLast(new NettyUdpClientPermeateClientTransferHandler(channelTypeAdapter));
+        pipeline.addLast(new NettyClientPermeateClientTransferHandler(channelTypeAdapter));
     }
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientPermeateClientTransferRealFilter.java

@@ -1,11 +1,11 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.filter;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.filter;
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.socket.SocketChannel;
 import io.netty.handler.timeout.IdleStateHandler;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.proxy.socks.handler.NettySocksClientProxyClientTransferHandler;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientPermeateClientTransferRealHandler;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter;
 import org.framework.lazy.cloud.network.heartbeat.common.decoder.NettyProxyMsgDecoder;
 import org.framework.lazy.cloud.network.heartbeat.common.encoder.NettyProxyMsgEncoder;
@@ -14,10 +14,10 @@ import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInit
 /**
  * netty 客户端连接真实服服务端访客拦截器
  */
-public class NettySocksClientProxyClientTransferFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyClientPermeateClientTransferRealFilter extends DebugChannelInitializer<SocketChannel> {
     private final ChannelTypeAdapter channelTypeAdapter;
 
-    public NettySocksClientProxyClientTransferFilter(ChannelTypeAdapter channelTypeAdapter) {
+    public NettyClientPermeateClientTransferRealFilter(ChannelTypeAdapter channelTypeAdapter) {
         this.channelTypeAdapter = channelTypeAdapter;
     }
 
@@ -41,6 +41,6 @@ public class NettySocksClientProxyClientTransferFilter extends DebugChannelIniti
 
         pipeline.addLast(new NettyProxyMsgDecoder(Integer.MAX_VALUE, 0, 4, -4, 0));
         pipeline.addLast(new NettyProxyMsgEncoder());
-        pipeline.addLast(new NettySocksClientProxyClientTransferHandler(channelTypeAdapter));
+        pipeline.addLast(new NettyClientPermeateClientTransferRealHandler(channelTypeAdapter));
     }
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientPermeateClientVisitorFilter.java

@@ -1,20 +1,20 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.filter;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.filter;
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelDuplexHandler;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.socket.SocketChannel;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.NettyClientPermeateClientVisitor;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler.NettyTcpClientPermeateClientVisitorHandler;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.InternalNetworkClientPermeateClientVisitor;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientPermeateClientVisitorHandler;
 import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer;
 
-public class NettyTcpClientPermeateClientVisitorFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyClientPermeateClientVisitorFilter extends DebugChannelInitializer<SocketChannel> {
 
-    private final NettyClientPermeateClientVisitor nettyClientPermeateClientVisitor;
+    private final InternalNetworkClientPermeateClientVisitor internalNetworkClientPermeateClientVisitor;
 
-    public NettyTcpClientPermeateClientVisitorFilter(NettyClientPermeateClientVisitor nettyClientPermeateClientVisitor) {
-        this.nettyClientPermeateClientVisitor = nettyClientPermeateClientVisitor;
+    public NettyClientPermeateClientVisitorFilter(InternalNetworkClientPermeateClientVisitor internalNetworkClientPermeateClientVisitor) {
+        this.internalNetworkClientPermeateClientVisitor = internalNetworkClientPermeateClientVisitor;
 
     }
 
@@ -31,6 +31,6 @@ public class NettyTcpClientPermeateClientVisitorFilter extends DebugChannelIniti
     protected void initChannel0(SocketChannel ch) throws Exception {
         ChannelPipeline pipeline = ch.pipeline();
         pipeline.addLast(new ChannelDuplexHandler());
-        pipeline.addLast(new NettyTcpClientPermeateClientVisitorHandler(nettyClientPermeateClientVisitor));
+        pipeline.addLast(new NettyClientPermeateClientVisitorHandler(internalNetworkClientPermeateClientVisitor));
     }
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientPermeateServerTransferFilter.java

@@ -1,11 +1,11 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.filter;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.filter;
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.socket.SocketChannel;
 import io.netty.handler.timeout.IdleStateHandler;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler.NettyTcpClientPermeateServerTransferHandler;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientPermeateServerTransferHandler;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter;
 import org.framework.lazy.cloud.network.heartbeat.common.decoder.NettyProxyMsgDecoder;
 import org.framework.lazy.cloud.network.heartbeat.common.encoder.NettyProxyMsgEncoder;
@@ -14,10 +14,10 @@ import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInit
 /**
  * netty 客户端渗透通信通道
  */
-public class NettyTcpClientPermeateServerTransferFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyClientPermeateServerTransferFilter extends DebugChannelInitializer<SocketChannel> {
     private final ChannelTypeAdapter channelTypeAdapter;
 
-    public NettyTcpClientPermeateServerTransferFilter(ChannelTypeAdapter channelTypeAdapter) {
+    public NettyClientPermeateServerTransferFilter(ChannelTypeAdapter channelTypeAdapter) {
         this.channelTypeAdapter = channelTypeAdapter;
     }
 
@@ -40,6 +40,6 @@ public class NettyTcpClientPermeateServerTransferFilter extends DebugChannelInit
         pipeline.addLast(new NettyProxyMsgDecoder(Integer.MAX_VALUE, 0, 4, -4, 0));
         pipeline.addLast(new IdleStateHandler(0, 4, 0));
         pipeline.addLast(new NettyProxyMsgEncoder());
-        pipeline.addLast(new NettyTcpClientPermeateServerTransferHandler(channelTypeAdapter));
+        pipeline.addLast(new NettyClientPermeateServerTransferHandler(channelTypeAdapter));
     }
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyClientPermeateServerVisitorFilter.java

@@ -1,20 +1,20 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.filter;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.filter;
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelDuplexHandler;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.socket.SocketChannel;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.NettyClientPermeateServerVisitor;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler.NettyTcpClientPermeateServerVisitorHandler;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.InternalNetworkClientPermeateServerVisitor;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyClientPermeateServerVisitorHandler;
 import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInitializer;
 
-public class NettyTcpClientPermeateServerVisitorFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyClientPermeateServerVisitorFilter extends DebugChannelInitializer<SocketChannel> {
 
-    private final NettyClientPermeateServerVisitor nettyClientPermeateServerVisitor;
+    private final InternalNetworkClientPermeateServerVisitor internalNetworkClientPermeateServerVisitor;
 
-    public NettyTcpClientPermeateServerVisitorFilter(NettyClientPermeateServerVisitor nettyClientPermeateServerVisitor) {
-        this.nettyClientPermeateServerVisitor = nettyClientPermeateServerVisitor;
+    public NettyClientPermeateServerVisitorFilter(InternalNetworkClientPermeateServerVisitor internalNetworkClientPermeateServerVisitor) {
+        this.internalNetworkClientPermeateServerVisitor = internalNetworkClientPermeateServerVisitor;
 
     }
 
@@ -31,6 +31,6 @@ public class NettyTcpClientPermeateServerVisitorFilter extends DebugChannelIniti
     protected void initChannel0(SocketChannel ch) throws Exception {
         ChannelPipeline pipeline = ch.pipeline();
         pipeline.addLast(new ChannelDuplexHandler());
-        pipeline.addLast(new NettyTcpClientPermeateServerVisitorHandler(nettyClientPermeateServerVisitor));
+        pipeline.addLast(new NettyClientPermeateServerVisitorHandler(internalNetworkClientPermeateServerVisitor));
     }
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyServerPermeateClientRealFilter.java

@@ -1,14 +1,14 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.filter;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.filter;
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.socket.SocketChannel;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler.NettyTcpServerPermeateClientRealHandler;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyServerPermeateClientRealHandler;
 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;
 
-public class NettyTcpServerPermeateClientRealFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyServerPermeateClientRealFilter 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}.
@@ -21,7 +21,7 @@ public class NettyTcpServerPermeateClientRealFilter extends DebugChannelInitiali
         // 解码、编码
         pipeline.addLast(new TransferDecoder(Integer.MAX_VALUE, 1024 * 1024*10));
         pipeline.addLast(new TransferEncoder());
-        pipeline.addLast(new NettyTcpServerPermeateClientRealHandler());
+        pipeline.addLast(new NettyServerPermeateClientRealHandler());
 
     }
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/filter/NettyServerPermeateClientTransferFilter.java

@@ -1,10 +1,10 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.filter;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.filter;
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.socket.SocketChannel;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler.NettyTcpServerPermeateClientTransferHandler;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.handler.NettyServerPermeateClientTransferHandler;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter;
 import org.framework.lazy.cloud.network.heartbeat.common.decoder.NettyProxyMsgDecoder;
 import org.framework.lazy.cloud.network.heartbeat.common.encoder.NettyProxyMsgEncoder;
@@ -13,10 +13,10 @@ import org.framework.lazy.cloud.network.heartbeat.common.filter.DebugChannelInit
 /**
  * netty 客户端连接真实服服务端访客拦截器
  */
-public class NettyTcpServerPermeateClientTransferFilter extends DebugChannelInitializer<SocketChannel> {
+public class NettyServerPermeateClientTransferFilter extends DebugChannelInitializer<SocketChannel> {
     private final ChannelTypeAdapter channelTypeAdapter;
 
-    public NettyTcpServerPermeateClientTransferFilter(ChannelTypeAdapter channelTypeAdapter) {
+    public NettyServerPermeateClientTransferFilter(ChannelTypeAdapter channelTypeAdapter) {
         this.channelTypeAdapter = channelTypeAdapter;
     }
 
@@ -37,6 +37,6 @@ public class NettyTcpServerPermeateClientTransferFilter extends DebugChannelInit
 //        pipeline.addLast(new NettMsgEncoder());
         pipeline.addLast(new NettyProxyMsgDecoder(Integer.MAX_VALUE, 0, 4, -4, 0));
         pipeline.addLast(new NettyProxyMsgEncoder());
-        pipeline.addLast(new NettyTcpServerPermeateClientTransferHandler(channelTypeAdapter));
+        pipeline.addLast(new NettyServerPermeateClientTransferHandler(channelTypeAdapter));
     }
 }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/HeartBeatClientHandler.java

@@ -1,4 +1,4 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.udp.handler;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.handler;
 
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
@@ -7,7 +7,7 @@ import io.netty.handler.timeout.IdleStateEvent;
 
 import java.util.Date;
 
-public class UdpHeartBeatClientHandler extends ChannelInboundHandlerAdapter {
+public class HeartBeatClientHandler extends ChannelInboundHandlerAdapter {
     private final int lossConnectCount = 0;
 
     @Override

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientHandler.java

@@ -1,4 +1,4 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.udp.handler;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.handler;
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
@@ -7,9 +7,9 @@ import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.handler.timeout.IdleState;
 import io.netty.handler.timeout.IdleStateEvent;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.udp.socket.NettyUdpClientSocket;
-import org.framework.lazy.cloud.network.heartbeat.common.constant.UdpMessageType;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientSocket;
+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.adapter.ChannelTypeAdapter;
 
 import java.nio.charset.StandardCharsets;
@@ -23,15 +23,15 @@ import java.util.concurrent.TimeUnit;
  * @date 2023/09/13 10:29
  */
 @Slf4j
-public class NettyUdpClientHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
+public class NettyClientHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
 
     private final ChannelTypeAdapter channelTypeAdapter;
-    private final NettyUdpClientSocket nettyUdpClientSocket;
+    private final NettyClientSocket nettyClientSocket;
 
 
-    public NettyUdpClientHandler(ChannelTypeAdapter channelTypeAdapter, NettyUdpClientSocket nettyUdpClientSocket) {
+    public NettyClientHandler(ChannelTypeAdapter channelTypeAdapter, NettyClientSocket nettyClientSocket) {
         this.channelTypeAdapter = channelTypeAdapter;
-        this.nettyUdpClientSocket = nettyUdpClientSocket;
+        this.nettyClientSocket = nettyClientSocket;
     }
 
     /**
@@ -47,7 +47,7 @@ public class NettyUdpClientHandler extends SimpleChannelInboundHandler<NettyProx
         // 接收服务端、或者是代理端的信息
         Channel channel = ctx.channel();
 //        log.info("type:{},clientId:{},data:{}",msg.getMysqlType(),new String(msg.getClientId()),new String(msg.getData()));
-        channelTypeAdapter.handler(ctx, msg);
+        channelTypeAdapter.handler(channel, msg);
     }
 
     /**
@@ -58,15 +58,13 @@ public class NettyUdpClientHandler extends SimpleChannelInboundHandler<NettyProx
         // 建立连接时
         log.info("When establishing a connection：{}" , new Date());
         ctx.fireChannelActive();
-        String clientId = nettyUdpClientSocket.getClientId();
-
+        String clientId = nettyClientSocket.getClientId();
         // 处理客户端连接成功
         Channel channel = ctx.channel();
         NettyProxyMsg nettyMsg = new NettyProxyMsg();
-        nettyMsg.setType(UdpMessageType.UDP_CLIENT_CHANNEL_ACTIVE);
+        nettyMsg.setType(MessageType.TCP_CLIENT_CHANNEL_ACTIVE);
         nettyMsg.setClientId(clientId);
-
-        channelTypeAdapter.handler(ctx, nettyMsg);
+        channelTypeAdapter.handler(channel, nettyMsg);
 
 
     }
@@ -81,7 +79,7 @@ public class NettyUdpClientHandler extends SimpleChannelInboundHandler<NettyProx
         final EventLoop eventLoop = ctx.channel().eventLoop();
         eventLoop.schedule(() -> {
             try {
-                nettyUdpClientSocket.newConnect2Server();
+                nettyClientSocket.newConnect2Server();
             } catch (InterruptedException e) {
                 throw new RuntimeException(e);
             }
@@ -97,20 +95,20 @@ public class NettyUdpClientHandler extends SimpleChannelInboundHandler<NettyProx
     public void userEventTriggered(ChannelHandlerContext ctx, Object obj) throws Exception {
         if (obj instanceof IdleStateEvent event) {
             if (IdleState.WRITER_IDLE.equals(event.state())) {  //如果写通道处于空闲状态,就发送心跳命令
-                String clientId = nettyUdpClientSocket.getClientId();
+                String clientId = nettyClientSocket.getClientId();
                 NettyProxyMsg nettyMsg = new NettyProxyMsg();
-                nettyMsg.setType(UdpMessageType.UDP_TYPE_HEARTBEAT);
+                nettyMsg.setType(MessageType.TCP_TYPE_HEARTBEAT);
                 nettyMsg.setData(clientId.getBytes(StandardCharsets.UTF_8));
                 nettyMsg.setClientId(clientId.getBytes(StandardCharsets.UTF_8));
                 ctx.writeAndFlush(nettyMsg);// 发送心跳数据
             } else if (event.state() == IdleState.WRITER_IDLE) { // 如果检测到写空闲状态，关闭连接
                 // 离线、暂存通知
-                String clientId = nettyUdpClientSocket.getClientId();
+                String clientId = nettyClientSocket.getClientId();
                 Channel channel = ctx.channel();
                 NettyProxyMsg nettyMsg = new NettyProxyMsg();
-                nettyMsg.setType(UdpMessageType.UDP_DISTRIBUTE_CLIENT_DISCONNECTION_NOTIFICATION);
+                nettyMsg.setType(MessageType.TCP_DISTRIBUTE_CLIENT_DISCONNECTION_NOTIFICATION);
                 nettyMsg.setClientId(clientId.getBytes(StandardCharsets.UTF_8));
-                channelTypeAdapter.handler(ctx, nettyMsg);
+                channelTypeAdapter.handler(channel, nettyMsg);
                 ctx.close();
             }
 

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateClientRealHandler.java

@@ -1,20 +1,23 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.handler;
 
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelOption;
 import io.netty.channel.SimpleChannelInboundHandler;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.common.constant.TcpMessageType;
+import org.framework.lazy.cloud.network.heartbeat.common.MessageType;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyByteBuf;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyCommunicationIdContext;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
+import org.wu.framework.core.utils.ObjectUtils;
 
 /**
  * 来自客户端 真实服务器返回的数据请求
  */
 @Slf4j
-public class NettyTcpClientPermeateClientRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
+public class NettyClientPermeateClientRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
 
 
     @Override
@@ -29,7 +32,7 @@ public class NettyTcpClientPermeateClientRealHandler extends SimpleChannelInboun
         // 访客通信通道 上报服务端代理完成
         Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(ctx.channel());
         NettyProxyMsg returnMessage = new NettyProxyMsg();
-        returnMessage.setType(TcpMessageType.TCP_REPORT_CLIENT_TRANSFER_CLIENT_RESPONSE);
+        returnMessage.setType(MessageType.TCP_REPORT_CLIENT_TRANSFER_CLIENT_RESPONSE);
         returnMessage.setVisitorId(visitorId);
         returnMessage.setClientId(clientId);
         returnMessage.setVisitorPort(visitorPort);
@@ -52,7 +55,7 @@ public class NettyTcpClientPermeateClientRealHandler extends SimpleChannelInboun
         if (nextChannel != null) {
             // 上报关闭这个客户端的访客通道
             NettyProxyMsg closeVisitorMsg = new NettyProxyMsg();
-            closeVisitorMsg.setType(TcpMessageType.TCP_REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE);
+            closeVisitorMsg.setType(MessageType.TCP_REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE);
             closeVisitorMsg.setVisitorId(visitorId);
             nextChannel.writeAndFlush(closeVisitorMsg);
         }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateClientTransferHandler.java

@@ -1,23 +1,27 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.handler;
 
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelOption;
 import io.netty.channel.SimpleChannelInboundHandler;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.common.constant.TcpMessageType;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
+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.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyRealIdContext;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
+import org.wu.framework.core.utils.ObjectUtils;
 
 /**
  * 客户端访客通信通道 处理器
  */
 @Slf4j
-public class NettyTcpClientPermeateClientTransferRealHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
+public class NettyClientPermeateClientTransferHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
     private final ChannelTypeAdapter channelTypeAdapter;
 
-    public NettyTcpClientPermeateClientTransferRealHandler(ChannelTypeAdapter channelTypeAdapter) {
+    public NettyClientPermeateClientTransferHandler(ChannelTypeAdapter channelTypeAdapter) {
         this.channelTypeAdapter = channelTypeAdapter;
     }
 
@@ -29,7 +33,7 @@ public class NettyTcpClientPermeateClientTransferRealHandler extends SimpleChann
     @Override
     public void channelRead0(ChannelHandlerContext ctx, NettyProxyMsg nettyProxyMsg) throws Exception {
         Channel channel = ctx.channel();
-        channelTypeAdapter.handler(ctx, nettyProxyMsg);
+        channelTypeAdapter.handler(channel, nettyProxyMsg);
 
     }
 
@@ -38,14 +42,12 @@ public class NettyTcpClientPermeateClientTransferRealHandler extends SimpleChann
 
         String clientId = ChannelAttributeKeyUtils.getClientId(ctx.channel());
         String visitorId = ChannelAttributeKeyUtils.getVisitorId(ctx.channel());
-        Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(ctx.channel());
-        log.warn("close client permeate client transfer real clientId:{} visitorId:{}", clientId, visitorId);
         // 关闭访客
+        Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(ctx.channel());
         if (nextChannel != null) {
-
             // 上报关闭这个客户端的访客通道
             NettyProxyMsg closeVisitorMsg = new NettyProxyMsg();
-            closeVisitorMsg.setType(TcpMessageType.TCP_REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE);
+            closeVisitorMsg.setType(MessageType.TCP_REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE);
             closeVisitorMsg.setVisitorId(visitorId);
             nextChannel.writeAndFlush(closeVisitorMsg);
         }
@@ -55,7 +57,6 @@ public class NettyTcpClientPermeateClientTransferRealHandler extends SimpleChann
 
     @Override
     public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
-        // 处理客户端本地真实通道问题
         if (ctx.channel().isWritable()) {
             log.debug("Channel is writable again");
             // 恢复之前暂停的操作，如写入数据

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateClientTransferRealHandler.java

@@ -1,23 +1,26 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.udp.handler;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.handler;
 
 
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelOption;
 import io.netty.channel.SimpleChannelInboundHandler;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.common.constant.UdpMessageType;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
+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.NettyRealIdContext;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
+import org.wu.framework.core.utils.ObjectUtils;
 
 /**
  * 客户端访客通信通道 处理器
  */
 @Slf4j
-public class NettyUdpClientPermeateClientTransferRealHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
+public class NettyClientPermeateClientTransferRealHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
     private final ChannelTypeAdapter channelTypeAdapter;
 
-    public NettyUdpClientPermeateClientTransferRealHandler(ChannelTypeAdapter channelTypeAdapter) {
+    public NettyClientPermeateClientTransferRealHandler(ChannelTypeAdapter channelTypeAdapter) {
         this.channelTypeAdapter = channelTypeAdapter;
     }
 
@@ -29,7 +32,7 @@ public class NettyUdpClientPermeateClientTransferRealHandler extends SimpleChann
     @Override
     public void channelRead0(ChannelHandlerContext ctx, NettyProxyMsg nettyProxyMsg) throws Exception {
         Channel channel = ctx.channel();
-        channelTypeAdapter.handler(ctx, nettyProxyMsg);
+        channelTypeAdapter.handler(channel, nettyProxyMsg);
 
     }
 
@@ -45,7 +48,7 @@ public class NettyUdpClientPermeateClientTransferRealHandler extends SimpleChann
 
             // 上报关闭这个客户端的访客通道
             NettyProxyMsg closeVisitorMsg = new NettyProxyMsg();
-            closeVisitorMsg.setType(UdpMessageType.UDP_REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE);
+            closeVisitorMsg.setType(MessageType.TCP_REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE);
             closeVisitorMsg.setVisitorId(visitorId);
             nextChannel.writeAndFlush(closeVisitorMsg);
         }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateClientVisitorHandler.java

@@ -1,4 +1,4 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.handler;
 
 
 import io.netty.buffer.ByteBuf;
@@ -8,31 +8,31 @@ import io.netty.channel.ChannelOption;
 import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.util.internal.StringUtil;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.NettyClientPermeateClientVisitor;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced.ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.socket.NettyTcpClientPermeateClientVisitorTransferSocket;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.socket.NettyTcpClientPermeateServerVisitorTransferSocket;
-import org.framework.lazy.cloud.network.heartbeat.common.constant.TcpMessageType;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.InternalNetworkClientPermeateClientVisitor;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.advanced.ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientPermeateClientVisitorTransferSocket;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientPermeateServerVisitorTransferSocket;
+import org.framework.lazy.cloud.network.heartbeat.common.MessageType;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyCommunicationIdContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyRealIdContext;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
 
 import java.util.UUID;
 
 @Slf4j
-public class NettyTcpClientPermeateClientVisitorHandler extends SimpleChannelInboundHandler<ByteBuf> {
-    private final NettyClientPermeateClientVisitor nettyClientPermeateClientVisitor;
+public class  NettyClientPermeateClientVisitorHandler extends SimpleChannelInboundHandler<ByteBuf> {
+    private final InternalNetworkClientPermeateClientVisitor internalNetworkClientPermeateClientVisitor;
 //    private final NettyChannelPool nettyChannelPool = new DefaultNettyChannelPool(10);
 
-    public NettyTcpClientPermeateClientVisitorHandler(NettyClientPermeateClientVisitor nettyClientPermeateClientVisitor) {
-        this.nettyClientPermeateClientVisitor = nettyClientPermeateClientVisitor;
+    public NettyClientPermeateClientVisitorHandler(InternalNetworkClientPermeateClientVisitor internalNetworkClientPermeateClientVisitor) {
+        this.internalNetworkClientPermeateClientVisitor = internalNetworkClientPermeateClientVisitor;
     }
 
     /**
      * @param ctx
      * @throws Exception
-     * @see NettyTcpClientPermeateServerVisitorTransferSocket
+     * @see NettyClientPermeateServerVisitorTransferSocket
      * @see ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced
      */
     @Override
@@ -53,7 +53,7 @@ public class NettyTcpClientPermeateClientVisitorHandler extends SimpleChannelInb
         // 判断是否有可用的通道 如果没有创建新的通道
 //        Channel transferChannel = nettyChannelPool.availableChannel(visitorId);
         // 创建访客连接客户端通道
-        NettyTcpClientPermeateClientVisitorTransferSocket.buildTransferServer(nettyClientPermeateClientVisitor,visitorChannel);
+        NettyClientPermeateClientVisitorTransferSocket.buildTransferServer(internalNetworkClientPermeateClientVisitor,visitorChannel);
         log.info("客户端渗透客户端访客:【{}】端口连接成功了",visitorId);
         super.channelActive(ctx);
     }
@@ -72,10 +72,10 @@ public class NettyTcpClientPermeateClientVisitorHandler extends SimpleChannelInb
         log.debug("【客户端渗透客户端】访客端口成功接收数据:{}", new String(bytes));
 
         // 使用访客的通信通道
-        Integer visitorPort = nettyClientPermeateClientVisitor.getVisitorPort();
-        String clientId = nettyClientPermeateClientVisitor.getNettyClientProperties().getClientId();
+        Integer visitorPort = internalNetworkClientPermeateClientVisitor.getVisitorPort();
+        String clientId = internalNetworkClientPermeateClientVisitor.getNettyClientProperties().getClientId();
         NettyProxyMsg nettyProxyMsg = new NettyProxyMsg();
-        nettyProxyMsg.setType(TcpMessageType.TCP_REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_REQUEST);
+        nettyProxyMsg.setType(MessageType.TCP_REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_REQUEST);
         nettyProxyMsg.setVisitorId(visitorId);
         nettyProxyMsg.setClientId(clientId);
         nettyProxyMsg.setVisitorPort(visitorPort);
@@ -102,7 +102,7 @@ public class NettyTcpClientPermeateClientVisitorHandler extends SimpleChannelInb
 
             //  通知客户端 关闭访问通道、真实通道
             NettyProxyMsg myMsg = new NettyProxyMsg();
-            myMsg.setType(TcpMessageType.TCP_REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE);
+            myMsg.setType(MessageType.TCP_REPORT_CLIENT_PERMEATE_CLIENT_TRANSFER_CLOSE);
             nextChannel.writeAndFlush(myMsg);
         }
         // 关闭 访客通信通道、访客真实通道

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateServerTransferHandler.java

@@ -1,4 +1,4 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.handler;
 
 
 import io.netty.channel.Channel;
@@ -7,19 +7,21 @@ import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.handler.timeout.IdleState;
 import io.netty.handler.timeout.IdleStateEvent;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.common.constant.TcpMessageType;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
+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.adapter.ChannelTypeAdapter;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
 
+import java.nio.charset.StandardCharsets;
+
 /**
  * 客户端访客通信通道 处理器
  */
 @Slf4j
-public class NettyTcpClientPermeateServerTransferHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
+public class NettyClientPermeateServerTransferHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
     private final ChannelTypeAdapter channelTypeAdapter;
 
-    public NettyTcpClientPermeateServerTransferHandler(ChannelTypeAdapter channelTypeAdapter) {
+    public NettyClientPermeateServerTransferHandler(ChannelTypeAdapter channelTypeAdapter) {
         this.channelTypeAdapter = channelTypeAdapter;
     }
 
@@ -31,7 +33,7 @@ public class NettyTcpClientPermeateServerTransferHandler extends SimpleChannelIn
     @Override
     public void channelRead0(ChannelHandlerContext ctx, NettyProxyMsg nettyProxyMsg) throws Exception {
         Channel channel = ctx.channel();
-        channelTypeAdapter.handler(ctx, nettyProxyMsg);
+        channelTypeAdapter.handler(channel, nettyProxyMsg);
 
     }
 
@@ -45,7 +47,7 @@ public class NettyTcpClientPermeateServerTransferHandler extends SimpleChannelIn
         if (nextChannel != null) {
             // 上报关闭服务端客户端真实通道
             NettyProxyMsg closeVisitorMsg = new NettyProxyMsg();
-            closeVisitorMsg.setType(TcpMessageType.TCP_TCP_REPORT_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE);
+            closeVisitorMsg.setType(MessageType.TCP_TCP_REPORT_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE);
             closeVisitorMsg.setVisitorId(visitorId);
             nextChannel.writeAndFlush(closeVisitorMsg);
         }
@@ -77,7 +79,7 @@ public class NettyTcpClientPermeateServerTransferHandler extends SimpleChannelIn
         if (obj instanceof IdleStateEvent event) {
             if (IdleState.WRITER_IDLE.equals(event.state())) {  //如果写通道处于空闲状态,就发送心跳命令
                 NettyProxyMsg nettyMsg = new NettyProxyMsg();
-                nettyMsg.setType(TcpMessageType.TCP_TYPE_HEARTBEAT);
+                nettyMsg.setType(MessageType.TCP_TYPE_HEARTBEAT);
                 ctx.writeAndFlush(nettyMsg);// 发送心跳数据
             } else if (event.state() == IdleState.WRITER_IDLE) { // 如果检测到写空闲状态，关闭连接
                 // 离线、暂存通知

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyClientPermeateServerVisitorHandler.java

@@ -1,4 +1,4 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.handler;
 
 
 import io.netty.buffer.ByteBuf;
@@ -8,28 +8,28 @@ import io.netty.channel.ChannelOption;
 import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.util.internal.StringUtil;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.NettyClientPermeateServerVisitor;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced.ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.socket.NettyTcpClientPermeateServerVisitorTransferSocket;
-import org.framework.lazy.cloud.network.heartbeat.common.constant.TcpMessageType;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.InternalNetworkClientPermeateServerVisitor;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.advanced.ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced;
+import org.framework.lazy.cloud.network.heartbeat.client.netty.socket.NettyClientPermeateServerVisitorTransferSocket;
+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 java.util.UUID;
 
 @Slf4j
-public class NettyTcpClientPermeateServerVisitorHandler extends SimpleChannelInboundHandler<ByteBuf> {
-    private final NettyClientPermeateServerVisitor nettyClientPermeateServerVisitor;
+public class NettyClientPermeateServerVisitorHandler extends SimpleChannelInboundHandler<ByteBuf> {
+    private final InternalNetworkClientPermeateServerVisitor internalNetworkClientPermeateServerVisitor;
 //    private final NettyChannelPool nettyChannelPool = new DefaultNettyChannelPool(10);
 
-    public NettyTcpClientPermeateServerVisitorHandler(NettyClientPermeateServerVisitor nettyClientPermeateServerVisitor) {
-        this.nettyClientPermeateServerVisitor = nettyClientPermeateServerVisitor;
+    public NettyClientPermeateServerVisitorHandler(InternalNetworkClientPermeateServerVisitor internalNetworkClientPermeateServerVisitor) {
+        this.internalNetworkClientPermeateServerVisitor = internalNetworkClientPermeateServerVisitor;
     }
 
     /**
      * @param ctx
      * @throws Exception
-     * @see NettyTcpClientPermeateServerVisitorTransferSocket
+     * @see NettyClientPermeateServerVisitorTransferSocket
      * @see ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced
      */
     @Override
@@ -41,14 +41,14 @@ public class NettyTcpClientPermeateServerVisitorHandler extends SimpleChannelInb
 
         // 生成访客ID
         String visitorId = UUID.randomUUID().toString();
-        Integer visitorPort = nettyClientPermeateServerVisitor.getVisitorPort();
+        Integer visitorPort = internalNetworkClientPermeateServerVisitor.getVisitorPort();
 
         log.info("this channel with visitor port:{} use visitorId:{}", visitorPort, visitorId);
         ChannelAttributeKeyUtils.buildVisitorId(visitorChannel, visitorId);
         // 判断是否有可用的通道 如果没有创建新的通道
 //        Channel transferChannel = nettyChannelPool.availableChannel(visitorId);
         // 创建访客连接服务端通道
-        NettyTcpClientPermeateServerVisitorTransferSocket.buildTransferServer(nettyClientPermeateServerVisitor,visitorChannel);
+        NettyClientPermeateServerVisitorTransferSocket.buildTransferServer(internalNetworkClientPermeateServerVisitor,visitorChannel);
         log.debug("客户端渗透服务端访客端口连接成功了,访客ID:{}", visitorId);
         super.channelActive(ctx);
     }
@@ -67,10 +67,10 @@ public class NettyTcpClientPermeateServerVisitorHandler extends SimpleChannelInb
         log.debug("【客户端渗透服务端】访客端口成功接收数据:{}", new String(bytes));
 
         // 使用访客的通信通道
-        Integer visitorPort = nettyClientPermeateServerVisitor.getVisitorPort();
-        String clientId = nettyClientPermeateServerVisitor.getNettyClientProperties().getClientId();
+        Integer visitorPort = internalNetworkClientPermeateServerVisitor.getVisitorPort();
+        String clientId = internalNetworkClientPermeateServerVisitor.getNettyClientProperties().getClientId();
         NettyProxyMsg nettyProxyMsg = new NettyProxyMsg();
-        nettyProxyMsg.setType(TcpMessageType.TCP_REPORT_CLIENT_PERMEATE_SERVER_TRANSFER);
+        nettyProxyMsg.setType(MessageType.TCP_REPORT_CLIENT_PERMEATE_SERVER_TRANSFER);
         nettyProxyMsg.setVisitorId(visitorId);
         nettyProxyMsg.setClientId(clientId);
         nettyProxyMsg.setVisitorPort(visitorPort);
@@ -95,7 +95,7 @@ public class NettyTcpClientPermeateServerVisitorHandler extends SimpleChannelInb
         if (nextChannel != null && nextChannel.isActive()) {
             //  通知服务端 关闭访问通道、真实通道
             NettyProxyMsg myMsg = new NettyProxyMsg();
-            myMsg.setType(TcpMessageType.TCP_TCP_REPORT_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE);
+            myMsg.setType(MessageType.TCP_TCP_REPORT_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE);
             myMsg.setVisitorId(visitorId);
             nextChannel.writeAndFlush(myMsg);
             //通信通道
@@ -136,7 +136,7 @@ public class NettyTcpClientPermeateServerVisitorHandler extends SimpleChannelInb
         if (nextChannel != null) {
             // 下发关闭访客
             NettyProxyMsg closeRealClient = new NettyProxyMsg();
-            closeRealClient.setType(TcpMessageType.TCP_TCP_REPORT_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE);
+            closeRealClient.setType(MessageType.TCP_TCP_REPORT_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE);
             closeRealClient.setClientId(clientId);
             closeRealClient.setVisitorId(visitorId);
             nextChannel.writeAndFlush(closeRealClient);

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyServerPermeateClientRealHandler.java

@@ -1,4 +1,4 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.handler;
 
 
 import io.netty.channel.Channel;
@@ -6,9 +6,9 @@ import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelOption;
 import io.netty.channel.SimpleChannelInboundHandler;
 import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.common.constant.TcpMessageType;
+import org.framework.lazy.cloud.network.heartbeat.common.MessageType;
 import org.framework.lazy.cloud.network.heartbeat.common.NettyByteBuf;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
+import org.framework.lazy.cloud.network.heartbeat.common.NettyProxyMsg;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
 import org.wu.framework.core.utils.ObjectUtils;
 
@@ -16,7 +16,7 @@ import org.wu.framework.core.utils.ObjectUtils;
  * 来自客户端 真实服务器返回的数据请求
  */
 @Slf4j
-public class NettyTcpServerPermeateClientRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
+public class NettyServerPermeateClientRealHandler extends SimpleChannelInboundHandler<NettyByteBuf> {
 
 
     @Override
@@ -31,7 +31,7 @@ public class NettyTcpServerPermeateClientRealHandler extends SimpleChannelInboun
         // 访客通信通道 上报服务端代理完成
         Channel visitor = ChannelAttributeKeyUtils.getNextChannel(ctx.channel());
         NettyProxyMsg returnMessage = new NettyProxyMsg();
-        returnMessage.setType(TcpMessageType.TCP_REPORT_CLIENT_TRANSFER);
+        returnMessage.setType(MessageType.TCP_REPORT_CLIENT_TRANSFER);
         returnMessage.setVisitorId(visitorId);
         returnMessage.setClientId(clientId);
         returnMessage.setVisitorPort(visitorPort);
@@ -55,7 +55,7 @@ public class NettyTcpServerPermeateClientRealHandler extends SimpleChannelInboun
         if (visitor != null) {
             // 上报关闭这个客户端的访客通道
             NettyProxyMsg closeVisitorMsg = new NettyProxyMsg();
-            closeVisitorMsg.setType(TcpMessageType.TCP_REPORT_SERVICE_PERMEATE_CLIENT_CLIENT_CLOSE_VISITOR);
+            closeVisitorMsg.setType(MessageType.TCP_REPORT_SERVICE_PERMEATE_CLIENT_CLIENT_CLOSE_VISITOR);
             closeVisitorMsg.setVisitorId(visitorId);
             visitor.writeAndFlush(closeVisitorMsg);
         }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/handler/NettyServerPermeateClientTransferHandler.java

@@ -1,4 +1,4 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler;
+package org.framework.lazy.cloud.network.heartbeat.client.netty.handler;
 
 
 import io.netty.channel.Channel;
@@ -6,9 +6,8 @@ import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelOption;
 import io.netty.channel.SimpleChannelInboundHandler;
 import lombok.extern.slf4j.Slf4j;
+import org.framework.lazy.cloud.network.heartbeat.common.*;
 import org.framework.lazy.cloud.network.heartbeat.common.adapter.ChannelTypeAdapter;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.constant.TcpMessageType;
 import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
 import org.wu.framework.core.utils.ObjectUtils;
 
@@ -16,10 +15,10 @@ import org.wu.framework.core.utils.ObjectUtils;
  * 客户端访客通信通道 处理器
  */
 @Slf4j
-public class NettyTcpServerPermeateClientTransferHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
+public class NettyServerPermeateClientTransferHandler extends SimpleChannelInboundHandler<NettyProxyMsg> {
     private final ChannelTypeAdapter channelTypeAdapter;
 
-    public NettyTcpServerPermeateClientTransferHandler(ChannelTypeAdapter channelTypeAdapter) {
+    public NettyServerPermeateClientTransferHandler(ChannelTypeAdapter channelTypeAdapter) {
         this.channelTypeAdapter = channelTypeAdapter;
     }
 
@@ -31,7 +30,7 @@ public class NettyTcpServerPermeateClientTransferHandler extends SimpleChannelIn
     @Override
     public void channelRead0(ChannelHandlerContext ctx, NettyProxyMsg nettyProxyMsg) throws Exception {
         Channel channel = ctx.channel();
-        channelTypeAdapter.handler(ctx, nettyProxyMsg);
+        channelTypeAdapter.handler(channel, nettyProxyMsg);
 
     }
 
@@ -45,7 +44,7 @@ public class NettyTcpServerPermeateClientTransferHandler extends SimpleChannelIn
         if (nextChannel != null) {
             // 上报关闭这个客户端的访客通道
             NettyProxyMsg closeVisitorMsg = new NettyProxyMsg();
-            closeVisitorMsg.setType(TcpMessageType.TCP_REPORT_SERVICE_PERMEATE_CLIENT_CLIENT_CLOSE_VISITOR);
+            closeVisitorMsg.setType(MessageType.TCP_REPORT_SERVICE_PERMEATE_CLIENT_CLIENT_CLOSE_VISITOR);
             closeVisitorMsg.setVisitorId(visitorId);
             nextChannel.writeAndFlush(closeVisitorMsg);
         }

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/permeate/NettyClientSocket.java

@@ -1,15 +0,0 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate;
-
-public interface NettyClientSocket {
-
-    /**
-     * 创建客户端链接服务端
-     * @throws InterruptedException 异常信息
-     */
-    void newConnect2Server() throws InterruptedException;
-
-    /**
-     * 关闭链接
-     */
-    void shutdown();
-}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/permeate/tcp/advanced/ClientHandleTcpChannelHeartbeatTypeAdvanced.java

@@ -1,32 +0,0 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
-
-
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.AbstractTcpHandleChannelHeartbeatTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.constant.TcpMessageType;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
-
-
-/**
- * 服务端 处理客户端心跳
- * TCP_TYPE_HEARTBEAT
- */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
-public class ClientHandleTcpChannelHeartbeatTypeAdvanced extends AbstractTcpHandleChannelHeartbeatTypeAdvanced<NettyProxyMsg> {
-
-    /**
-     * 处理当前数据
-     *
-     * @param nettyChannelContext 当前通道
-     * @param msg     通道数据
-     */
-    @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg msg) {
-        NettyProxyMsg hb = new NettyProxyMsg();
-        hb.setType(TcpMessageType.TCP_TYPE_HEARTBEAT);
-//        nettyChannelContext.writeAndFlush(hb);
-    }
-
-}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/permeate/tcp/advanced/ClientHandleTcpChannelTransferTypeAdvancedHandleDistributeTcpDistribute.java

@@ -1,64 +0,0 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
-
-
-import io.netty.buffer.ByteBuf;
-import io.netty.channel.Channel;
-import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeServicePermeateClientTransferTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
-import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
-
-
-/**
- * 服务端处理客户端数据传输
- *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_TRANSFER
- */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
-@Slf4j
-public class ClientHandleTcpChannelTransferTypeAdvancedHandleDistributeTcpDistribute extends AbstractHandleTcpDistributeServicePermeateClientTransferTypeAdvanced<NettyProxyMsg> {
-
-    private final NettyClientProperties nettyClientProperties;
-
-    public ClientHandleTcpChannelTransferTypeAdvancedHandleDistributeTcpDistribute(NettyClientProperties nettyClientProperties) {
-        this.nettyClientProperties = nettyClientProperties;
-    }
-
-    /**
-     * 处理当前数据
-     *
-     * @param nettyChannelContext       当前通道
-     * @param nettyProxyMsg 通道数据
-     */
-    @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
-        Channel channel = nettyChannelContext.channel();
-        log.debug("接收到服务端需要内网穿透的数据:{}" , nettyProxyMsg);
-        String clientId = nettyClientProperties.getClientId();
-        byte[] visitorPort = nettyProxyMsg.getVisitorPort();
-        byte[] clientTargetIp = nettyProxyMsg.getTargetIp();
-        byte[] clientTargetPort = nettyProxyMsg.getTargetPort();
-        byte[] visitorId = nettyProxyMsg.getVisitorId();
-        // 真实服务通道
-//        Channel realChannel = NettyRealIdContext.getReal(new String(visitorId));
-        Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel);
-        if (nextChannel == null) {
-            log.error("无法获取访客:{} 真实服务", new String(visitorId));
-            return;
-        }
-
-
-        // 把数据转到真实服务
-        ByteBuf buf = channel.config().getAllocator().buffer(nettyProxyMsg.getData().length);
-        buf.writeBytes(nettyProxyMsg.getData());
-
-        nextChannel.writeAndFlush(buf);
-
-    }
-
-}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/permeate/tcp/advanced/ClientHandleTcpClientChannelActiveAdvanced.java

@@ -1,39 +0,0 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
-
-import io.netty.channel.Channel;
-import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
-import org.framework.lazy.cloud.network.heartbeat.common.ChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpClientChannelActiveAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
-
-/**
- * 客户端通道 is active
- */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
-public class ClientHandleTcpClientChannelActiveAdvanced extends AbstractHandleTcpClientChannelActiveAdvanced<NettyProxyMsg> {
-    private final NettyClientProperties nettyClientProperties;
-
-    public ClientHandleTcpClientChannelActiveAdvanced(NettyClientProperties nettyClientProperties) {
-        this.nettyClientProperties = nettyClientProperties;
-    }
-
-    /**
-     * 处理当前数据
-     *
-     * @param nettyChannelContext       当前通道
-     * @param nettyProxyMsg 通道数据
-     */
-    @Override
-    protected void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
-        Channel channel = nettyChannelContext.channel();
-        // 缓存当前通道
-        String clientId = nettyProxyMsg.clientId();
-
-        ChannelContext.push(channel, clientId);
-        ChannelAttributeKeyUtils.buildClientId(channel, clientId);
-    }
-}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/permeate/tcp/advanced/ClientHandleTcpDistributeClientPermeateClientInitTypeAdvanced.java

@@ -1,75 +0,0 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
-
-
-import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.client.config.NettyClientProperties;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.socket.NettyTcpClientPermeateClientVisitorSocket;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.HandleChannelTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeClientPermeateClientInitTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
-import org.wu.framework.spring.utils.SpringContextHolder;
-
-import java.util.ArrayList;
-import java.util.List;
-
-
-/**
- * 客户端渗透客户端init信息
- *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_CLIENT_INIT
- */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
-@Slf4j
-public class ClientHandleTcpDistributeClientPermeateClientInitTypeAdvanced
-        extends AbstractHandleTcpDistributeClientPermeateClientInitTypeAdvanced<NettyProxyMsg> {
-
-    /**
-     * 处理当前数据
-     *
-     * @param nettyChannelContext       当前通道
-     * @param nettyProxyMsg 通道数据
-     */
-    @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
-        // 初始化 客户端渗透服务端socket
-        byte[] originClientIdBytes = nettyProxyMsg.getClientId();
-        byte[] visitorPortBytes = nettyProxyMsg.getVisitorPort();
-        byte[] clientTargetIpBytes = nettyProxyMsg.getTargetIp();
-        byte[] clientTargetPortBytes = nettyProxyMsg.getTargetPort();
-        byte[] targetClientIdBytes = nettyProxyMsg.getData();
-
-        String originClientId = new String(originClientIdBytes);
-        String targetClientId = new String(targetClientIdBytes);
-        Integer visitorPort = Integer.parseInt(new String(visitorPortBytes));
-        String clientTargetIp = new String(clientTargetIpBytes);
-        Integer clientTargetPort = Integer.parseInt(new String(clientTargetPortBytes));
-
-        List<HandleChannelTypeAdvanced> handleChannelTypeAdvancedList = new ArrayList<>(SpringContextHolder.getApplicationContext().getBeansOfType(HandleChannelTypeAdvanced.class).values());
-//        ChannelFlowAdapter channelFlowAdapter = SpringContextHolder.getBean(ChannelFlowAdapter.class);
-        NettyClientProperties nettyClientProperties = SpringContextHolder.getBean(NettyClientProperties.class);
-        log.info("client permeate client from client_id:【{}】 target_client_id【{}】with visitor_port【{}】, clientTargetIp:【{}】clientTargetPort:【{}】",
-                originClientId, targetClientId, visitorPort, clientTargetIp, clientTargetPort);
-        NettyTcpClientPermeateClientVisitorSocket nettyTcpClientPermeateClientVisitorSocket =
-                NettyTcpClientPermeateClientVisitorSocket.NettyClientPermeateClientVisitorSocketBuilder.builder()
-                        .builderClientId(originClientId)
-                        .builderClientTargetIp(clientTargetIp)
-                        .builderClientTargetPort(clientTargetPort)
-                        .builderVisitorPort(visitorPort)
-                        .builderNettyClientProperties(nettyClientProperties)
-                        //.builderChannelFlowAdapter(channelFlowAdapter)
-                        .builderToClientId(targetClientId)
-                        .builderHandleChannelTypeAdvancedList(handleChannelTypeAdvancedList)
-
-                .build();
-        try {
-            nettyTcpClientPermeateClientVisitorSocket.start();
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/permeate/tcp/advanced/ClientHandleTcpDistributeClientPermeateServerTransferCloseTypeAdvanced.java

@@ -1,39 +0,0 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
-
-
-import io.netty.channel.Channel;
-import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeClientPermeateServerTransferCloseTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
-import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
-
-
-/**
- * 下发 客户端渗透服务端通信通道关闭
- *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_PERMEATE_SERVER_TRANSFER_CLOSE
- */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
-@Slf4j
-public class ClientHandleTcpDistributeClientPermeateServerTransferCloseTypeAdvanced extends AbstractHandleTcpDistributeClientPermeateServerTransferCloseTypeAdvanced<NettyProxyMsg> {
-
-    /**
-     * 处理当前数据
-     *
-     * @param nettyChannelContext       当前通道
-     * @param nettyProxyMsg 通道数据
-     */
-    @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
-        Channel channel = nettyChannelContext.channel();
-        //  关闭本地通信通道
-        Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel);
-        channel.close();
-        nextChannel.close();
-    }
-
-}

wu-lazy-cloud-heartbeat-client/src/main/java/org/framework/lazy/cloud/network/heartbeat/client/netty/permeate/tcp/advanced/ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced.java

@@ -1,48 +0,0 @@
-package org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.advanced;
-
-
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelOption;
-import lombok.extern.slf4j.Slf4j;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.handler.NettyTcpClientPermeateServerVisitorHandler;
-import org.framework.lazy.cloud.network.heartbeat.client.netty.permeate.tcp.socket.NettyTcpClientPermeateServerVisitorTransferSocket;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyChannelContext;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.payload.NettyProxyMsg;
-import org.framework.lazy.cloud.network.heartbeat.common.advanced.permeate.tcp.client.AbstractHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced;
-import org.framework.lazy.cloud.network.heartbeat.common.enums.TcpMessageTypeEnums;
-import org.framework.lazy.cloud.network.heartbeat.common.utils.ChannelAttributeKeyUtils;
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Role;
-
-
-/**
- * 客户端渗透服务端数据传输通道连接成功
- * @see NettyTcpClientPermeateServerVisitorTransferSocket
- * @see NettyTcpClientPermeateServerVisitorHandler
- *
- * @see TcpMessageTypeEnums#TCP_DISTRIBUTE_CLIENT_TRANSFER_SERVER_PERMEATE_CHANNEL_CONNECTION_SUCCESSFUL
- */
-@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
-@Slf4j
-public class ClientHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced extends AbstractHandleTcpDistributeClientTransferServerPermeateChannelConnectionSuccessfulTypeAdvanced<NettyProxyMsg> {
-
-
-
-    /**
-     * 处理当前数据
-     *
-     * @param nettyChannelContext       当前通道
-     * @param nettyProxyMsg 通道数据
-     */
-    @Override
-    public void doHandler(NettyChannelContext nettyChannelContext, NettyProxyMsg nettyProxyMsg) {
-        Channel channel = nettyChannelContext.channel();
-        // 连接成功 开启自动读取写
-        byte[] msgVisitorId = nettyProxyMsg.getVisitorId();
-        String visitorId = new String(msgVisitorId);
-        Channel nextChannel = ChannelAttributeKeyUtils.getNextChannel(channel);
-        nextChannel.config().setOption(ChannelOption.AUTO_READ, true);
-
-    }
-
-}