解决后台分页查询的已知问题

更新workflows.
更新workflows
2024-04-09 11:51:49 +08:00 · 2024-03-22 23:14:18 +08:00 · 2024-03-22 22:24:20 +08:00 · 2024-03-22 21:43:19 +08:00 · 2024-02-19 18:20:30 +08:00 · 2024-02-01 21:05:33 +08:00
64 changed files with 1826 additions and 522 deletions
@@ -69,6 +69,7 @@ jobs:
    - name: Build with Maven (neutrino-proxy-client)
      run: |
        set MAVEN_OPTS="-Duser.language=UTF-8 -Dfile.encoding=UTF-8"
+        mvn clean install -U -pl neutrino-proxy-client -am -DskipTests --no-transfer-progress
        cd neutrino-proxy-client
        mvn clean package --file pom.xml --no-transfer-progress
        mvn clean native:compile -P native --file pom.xml --no-transfer-progress
@@ -60,3 +60,5 @@ logs
 data
 **/cert/**
 neutrino-proxy-server/src/main/resources/static/**
+
+client+/neutrino-proxy-client-chrome-plugin
@@ -91,6 +91,9 @@
 <a href="https://gitee.com/nichenxyx" target="_blank">
 <img src="assets/developer/NichenFly.jpg" width="11%">
 </a>
+<a href="https://gitee.com/giteeClass" target="_blank">
+<img src="assets/developer/coder.png" width="11%">
+</a>
 </p>

 #  ❤️ 感谢
@@ -79,3 +79,9 @@
 - 支持对用户、license限速
 - 修复HTTP(S)映射时使用tcp端口访问正常，使用域名访问偶现一直loading的问题
 - 修复HTTP(S)映射时使用映射的域名上传文件时，连接中断的问题
+
+## 2.0.2
+- 升级solon版本到2.7.0-M2，解决不在当前目录下启动时找不到配置文件的问题
+- client抽出sdk（还需测试windows原生部署、进一步抽出neutrino-proxy-sdk）
+- 修复管理后台分页查询的已知问题
+- 修复native下，批量删除端口池报错的问题
@@ -0,0 +1,16 @@
+FROM openjdk:21-jdk-oracle
+#同步时间
+#RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g' /etc/apk/repositories && \
+#    apk update && apk add wget unzip vim && apk add -U tzdata && \
+#    ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone
+# 设置时区为北京时间
+ENV TZ=Asia/Shanghai
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+RUN mkdir -p /root/neutrino-proxy/config
+WORKDIR /root/neutrino-proxy
+COPY ./target/neutrino-proxy-client.jar /root/neutrino-proxy/neutrino-proxy-client.jar
+COPY src/main/resources/app-copy.yml /root/neutrino-proxy/config/app.yml
+#VOLUME ["/root/neutrino-proxy"]
+ENTRYPOINT ["java","-jar","neutrino-proxy-client.jar","config=./config/app.yml"]
+
+#docker run -it -d --restart=always --name np_client -e SERVER_IP=127.0.0.1
@@ -0,0 +1,211 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>io.github.javpower</groupId>
+    <artifactId>neutrino-proxy-client-spring-boot-starter</artifactId>
+    <version>2.0.1</version>
+    <name>neutrino-proxy-client-spring-boot-starter</name>
+    <description>a tool about easy neutrino-proxy-client</description>
+    <url>https://github.com/javpower/neutrino-proxy</url>
+    <licenses>
+        <license>
+            <name> The Apache Software License, Version 2.0 </name>
+            <url> http://www.apache.org/licenses/LICENSE-2.0.txt </url>
+            <distribution> repo </distribution>
+        </license>
+    </licenses>
+    <scm>
+        <url>https://github.com/javpower/neutrino-proxy</url>
+        <connection>scm:[email protected]/javpower/neutrino-proxy.git</connection>
+        <developerConnection>scm:[email protected]/javpower/neutrino-proxy.git</developerConnection>
+    </scm>
+    <developers>
+        <developer>
+            <name>gc.x</name>
+            <email>[email protected]</email>
+            <organization> https://github.com/javpower</organization>
+            <timezone>+8</timezone>
+        </developer>
+    </developers>
+    <properties>
+        <mica-auto.version>2.3.2</mica-auto.version>
+        <spring-boot.version>2.7.13</spring-boot.version>
+        <revision>2.0.1</revision>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.dromara.neutrino-proxy</groupId>
+            <artifactId>neutrino-proxy-client-sdk</artifactId>
+            <version>${revision}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.slf4j</groupId>
+            <artifactId>slf4j-api</artifactId>
+            <version>1.7.36</version>
+        </dependency>
+        <!-- 其他依赖项... -->
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <version>1.2.12</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>1.18.30</version>
+        </dependency>
+        <!--SSH中转隧道-->
+        <dependency>
+            <groupId>com.jcraft</groupId>
+            <artifactId>jsch</artifactId>
+            <version>0.1.54</version>
+        </dependency>
+        <dependency>
+            <groupId>com.jcraft</groupId>
+            <artifactId>jzlib</artifactId>
+            <version>1.1.3</version>
+        </dependency>
+        <dependency>
+            <groupId>net.dreamlu</groupId>
+            <artifactId>mica-auto</artifactId>
+            <version>${mica-auto.version}</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-dependencies</artifactId>
+                <version>${spring-boot.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <distributionManagement>
+        <snapshotRepository>
+            <id>ossrh</id>
+            <url>https://s01.oss.sonatype.org/content/repositories/snapshots</url>
+        </snapshotRepository>
+        <repository>
+            <id>ossrh</id>
+            <url> https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/</url>
+        </repository>
+    </distributionManagement>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>3.8.1</version>
+                <configuration>
+                    <source>8</source>
+                    <target>8</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.1.0</version>
+                <configuration>
+                    <archive>
+                        <manifest>
+                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
+                        </manifest>
+                    </archive>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>${spring-boot.version}</version>
+                <configuration>
+                    <mainClass>org.dromara.neutrinoproxy.client.starter.SpringProxyClient</mainClass>
+                    <skip>true</skip>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.sonatype.plugins</groupId>
+                <artifactId>nexus-staging-maven-plugin</artifactId>
+                <version>1.6.7</version>
+                <extensions>true</extensions>
+                <configuration>
+                    <serverId>ossrh</serverId>
+                    <nexusUrl>https://s01.oss.sonatype.org/</nexusUrl>
+                    <autoReleaseAfterClose>true</autoReleaseAfterClose>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId> org.apache.maven.plugins</groupId>
+                <artifactId>maven-source-plugin</artifactId>
+                <version>2.2.1</version>
+                <executions>
+                    <execution>
+                        <id>attach-sources</id>
+                        <goals>
+                            <goal>jar-no-fork</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+                <version>2.9.1</version>
+                <configuration>
+                    <show>private</show>
+                    <nohelp>true</nohelp>
+                    <charset>UTF-8</charset>
+                    <encoding>UTF-8</encoding>
+                    <docencoding>UTF-8</docencoding>
+                    <additionalparam>-Xdoclint:none</additionalparam>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-gpg-plugin</artifactId>
+                <version>1.5</version>
+                <executions>
+                    <execution>
+                        <id>sign-artifacts</id>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>sign</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-deploy-plugin</artifactId>
+                <version>2.8.2</version>
+            </plugin>
+
+        </plugins>
+    </build>
+</project>
@@ -0,0 +1,19 @@
+package org.dromara.neutrinoproxy.client.starter;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+/**
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+@SpringBootApplication
+@Slf4j
+public class SpringProxyClient {
+
+    public static void main(String[] args) {
+        SpringApplication.run(SpringProxyClient.class, args);
+    }
+
+}
@@ -0,0 +1,19 @@
+package org.dromara.neutrinoproxy.client.starter.config;
+
+import org.dromara.neutrinoproxy.client.starter.util.ApplicationContextUtils;
+import org.springframework.context.ApplicationListener;
+import org.springframework.context.event.ContextRefreshedEvent;
+import org.springframework.stereotype.Component;
+
+/**
+ * 启动监听
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+@Component
+public class MainBusListeners implements ApplicationListener<ContextRefreshedEvent> {
+    @Override
+    public void onApplicationEvent(ContextRefreshedEvent event) {
+        ApplicationContextUtils.setContext(event.getApplicationContext());
+    }
+}
@@ -0,0 +1,25 @@
+package org.dromara.neutrinoproxy.client.starter.config;
+
+import org.dromara.neutrinoproxy.client.sdk.handler.ProxyMessageFactory;
+import org.dromara.neutrinoproxy.client.starter.util.ApplicationContextUtils;
+import org.springframework.stereotype.Component;
+
+
+/**
+ * 代理配置
+ * @author: aoshiguchen
+ * @date: 2022/10/8
+ */
+@Component
+public class ProxyConfiguration extends ProxyMessageFactory {
+
+    @Override
+    public void stop() {
+        ApplicationContextUtils.stop();
+    }
+
+    @Override
+    public boolean isAotRuntime() {
+        return false;
+    }
+}
@@ -0,0 +1,78 @@
+package org.dromara.neutrinoproxy.client.starter.config;
+
+import lombok.Data;
+import org.dromara.neutrinoproxy.client.starter.ssh.SSHProxy;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+/**
+ *
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+@Data
+@ConfigurationProperties(prefix = "neutrino.proxy")
+@Component
+public class SpringProxyConfig {
+    private Boolean enable=false;
+    private Boolean sshEnable=false;
+	private Protocol protocol;
+	private Tunnel tunnel;
+	private Client client;
+    private List<SSHProxy> sshProxys;
+
+	@Data
+	public static class Protocol {
+		private Integer maxFrameLength;
+		private Integer lengthFieldOffset;
+		private Integer lengthFieldLength;
+		private Integer initialBytesToStrip;
+		private Integer lengthAdjustment;
+		private Integer readIdleTime;
+		private Integer writeIdleTime;
+		private Integer allIdleTimeSeconds;
+	}
+
+	@Data
+	public static class Tunnel {
+		private String keyStorePassword;
+		private String jksPath;
+		private String serverIp;
+		private Integer serverPort;
+		private Boolean sslEnable;
+		private Integer obtainLicenseInterval;
+		private String licenseKey;
+		private Integer threadCount;
+		private String clientId;
+		private Boolean transferLogEnable;
+		private Boolean heartbeatLogEnable;
+		private Reconnection reconnection;
+	}
+
+	@Data
+	public static class Client {
+//		private Tcp tcp;
+		private Udp udp;
+	}
+
+	@Data
+	public static class Reconnection {
+		private Integer intervalSeconds;
+		private Boolean unlimited;
+	}
+
+	@Data
+	public static class Tcp {
+
+	}
+
+	@Data
+	public static class Udp {
+		private Integer bossThreadCount;
+		private Integer workThreadCount;
+		private String puppetPortRange;
+		private Boolean transferLogEnable;
+	}
+}
@@ -0,0 +1,42 @@
+package org.dromara.neutrinoproxy.client.starter.core;
+
+import cn.hutool.core.bean.BeanUtil;
+import lombok.extern.slf4j.Slf4j;
+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
+import org.dromara.neutrinoproxy.client.starter.config.ProxyConfiguration;
+import org.dromara.neutrinoproxy.client.starter.config.SpringProxyConfig;
+import org.dromara.neutrinoproxy.client.starter.ssh.SSHConnectionFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.stereotype.Component;
+
+/**
+ * 代理客户端服务
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+@Slf4j
+@Component
+public class ProxyClientService implements ApplicationRunner {
+
+    @Autowired
+    private ProxyConfiguration proxyConfiguration;
+    @Autowired
+    private SpringProxyConfig springProxyConfig;
+    @Override
+    public void run(ApplicationArguments args) {
+        if(springProxyConfig.getEnable()){
+            log.info("start....");
+            ProxyConfig proxyConfig = BeanUtil.toBean(springProxyConfig, ProxyConfig.class);
+            proxyConfiguration.start(proxyConfig);
+            log.info("start success!");
+        }
+        if(springProxyConfig.getSshEnable()){
+            springProxyConfig.getSshProxys().forEach(sshProxy -> {
+                String sshId = SSHConnectionFactory.factory.addConnection(sshProxy);
+                SSHConnectionFactory.factory.openTunnel(sshId);
+            });
+        }
+    }
+}
@@ -0,0 +1,10 @@
+package org.dromara.neutrinoproxy.client.starter.ssh;
+
+/**
+ *
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+public class SSHConnectionFactory {
+    public static final SSHConnectionService factory = new SSHConnectionServiceImpl();
+}
@@ -0,0 +1,14 @@
+package org.dromara.neutrinoproxy.client.starter.ssh;
+
+/**
+ *
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+public interface SSHConnectionService {
+    String addConnection(String host, String username, String password, int localPort, int remotePort,String remoteHost);
+    String addConnection(SSHProxy sshProxy);
+    void openTunnel(String sshId);
+    void closeTunnel(String sshId);
+    void closeAllTunnels();
+}
@@ -0,0 +1,71 @@
+package org.dromara.neutrinoproxy.client.starter.ssh;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+/**
+ *
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+public class SSHConnectionServiceImpl implements SSHConnectionService {
+
+    private Map<String, SSHProxy> connections;
+    private Map<String, SSHProxyFactory> factories;
+
+    public SSHConnectionServiceImpl() {
+        connections = new HashMap<>();
+        factories = new HashMap<>();
+    }
+
+    @Override
+    public String addConnection(String host, String username, String password, int localPort, int remotePort,String remoteHost) {
+        SSHProxy connection = new SSHProxy();
+        String sshId = UUID.randomUUID().toString();
+        connection.setSshId(sshId);
+        connection.setHost(host);
+        connection.setUsername(username);
+        connection.setPassword(password);
+        connection.setLocalPort(localPort);
+        connection.setRemotePort(remotePort);
+        connection.setRemoteHost(remoteHost);
+        connections.put(connection.getSshId(), connection);
+        return sshId;
+    }
+    @Override
+    public String addConnection(SSHProxy sshProxy) {
+        String sshId = UUID.randomUUID().toString();
+        sshProxy.setSshId(sshId);
+        connections.put(sshProxy.getSshId(), sshProxy);
+        return sshId;
+    }
+
+    @Override
+    public void openTunnel(String sshId) {
+        SSHProxy connection = connections.get(sshId);
+        if (connection != null && !factories.containsKey(sshId)) {
+            SSHProxyFactory factory = new SSHProxyFactoryImpl(connection);
+            factory.openTunnel();
+            factories.put(sshId, factory);
+        }
+    }
+
+    @Override
+    public void closeTunnel(String sshId) {
+        SSHProxyFactory factory = factories.get(sshId);
+
+        if (factory != null) {
+            factory.closeTunnel();
+            factories.remove(sshId);
+        }
+    }
+
+    @Override
+    public void closeAllTunnels() {
+        for (Map.Entry<String, SSHProxyFactory> entry : factories.entrySet()) {
+            SSHProxyFactory factory = entry.getValue();
+            factory.closeTunnel();
+        }
+        factories.clear();
+    }
+}
@@ -0,0 +1,27 @@
+package org.dromara.neutrinoproxy.client.starter.ssh;
+
+import lombok.Data;
+/**
+ *
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+@Data
+public class SSHProxy {
+    private String sshId;
+
+    //跳板机服务器公网IP
+    private String host;
+    //跳板机服务器登录名
+    private String username;
+    //跳板机登陆密码
+    private String password;
+    //本地的端口
+    private int localPort;
+
+    //需代理服务器端口号
+    private int remotePort;
+    //需代理服务器ip
+    private String remoteHost;
+
+}
@@ -0,0 +1,10 @@
+package org.dromara.neutrinoproxy.client.starter.ssh;
+/**
+ *
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+public interface SSHProxyFactory {
+    void openTunnel();
+    void closeTunnel();
+}
@@ -0,0 +1,63 @@
+package org.dromara.neutrinoproxy.client.starter.ssh;
+
+import com.jcraft.jsch.JSch;
+import com.jcraft.jsch.Session;
+import lombok.extern.slf4j.Slf4j;
+/**
+ *
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+@Slf4j
+public class SSHProxyFactoryImpl implements SSHProxyFactory {
+    private SSHProxy connection;
+    private Session session;
+
+    public SSHProxyFactoryImpl(SSHProxy connection) {
+        this.connection = connection;
+    }
+
+    @Override
+    public void openTunnel() {
+        try {
+            JSch jsch = new JSch();
+            session = jsch.getSession(connection.getUsername(), connection.getHost(), 22);
+            session.setPassword(connection.getPassword());
+            // 开启调试模式，打印更多详细日志
+            java.util.Properties config = new java.util.Properties();
+            config.put("StrictHostKeyChecking", "no");
+            config.put("userauth.gssapi-with-mic", "no");
+            config.put("compression.s2c", "[email protected],zlib,none");
+            config.put("compression.c2s", "[email protected],zlib,none");
+            session.setConfig(config);
+            session.setDaemonThread(true);
+            JSch.setLogger(new com.jcraft.jsch.Logger() {
+                public boolean isEnabled(int level) {
+                    return true;
+                }
+                public void log(int level, String message) {
+                    log.info("JSch - " + level + ": " + message);
+                }
+            });
+
+            int assignedPort = session.setPortForwardingL(connection.getLocalPort(), connection.getRemoteHost(), connection.getRemotePort());
+            session.connect(10000);
+            if (assignedPort != -1) {
+                log.info("SSH connection established successfully!");
+            }  else {
+                log.info("Failed to establish SSH connection!");
+            }
+        } catch (Exception e) {
+            // 异常处理
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public void closeTunnel() {
+        if (session != null && session.isConnected()) {
+            session.disconnect();
+            log.info("SSH connection closed successfully!");
+        }
+    }
+}
@@ -0,0 +1,44 @@
+package org.dromara.neutrinoproxy.client.starter.util;
+
+import org.springframework.beans.factory.support.DefaultListableBeanFactory;
+import org.springframework.beans.factory.support.GenericBeanDefinition;
+import org.springframework.boot.SpringApplication;
+import org.springframework.context.ApplicationContext;
+
+/**
+ * ApplicaitonContext工具类
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+public class ApplicationContextUtils {
+
+    private static ApplicationContext context;
+
+    public static void setContext(ApplicationContext applicationContext) {
+        context = applicationContext;
+    }
+
+    public static Object getBean(String beanName) {
+        return context.getBean(beanName);
+    }
+    public static void stop(){
+        SpringApplication.exit(context);
+    }
+    public static <T> T getBean(String beanName,Class<T> t) {
+        return context.getBean(beanName,t);
+    }
+    public static <T> T getBean(Class<T> t) {
+        return context.getBean(t);
+    }
+
+    public static void addBean(String beanName,Object bean){
+        // 获取BeanFactory
+        DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) context.getAutowireCapableBeanFactory();
+        // 创建Bean信息
+        GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
+        beanDefinition.setBeanClass(bean.getClass());
+        beanDefinition.setInstanceSupplier(() -> bean);
+        // 注入Bean
+        beanFactory.registerBeanDefinition(beanName, beanDefinition);
+    }
+}
@@ -0,0 +1,139 @@
+package org.dromara.neutrinoproxy.client.starter.util;
+
+import com.jcraft.jsch.*;
+import lombok.extern.slf4j.Slf4j;
+
+import java.io.*;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicLong;
+/**
+ * 远程发布工具类
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+@Slf4j
+public class RemoteDeployUtil {
+
+    public static void uploadAndStartJar(List<String> localFilePaths, String remoteDirectory, String remoteStartCommand,
+                                  String remoteUsername, String remoteHost, String remotePassword) {
+        log.info("Start=================");
+        JSch jsch = new JSch();
+        Session session = null;
+        ChannelSftp channelSftp = null;
+        try {
+            session = jsch.getSession(remoteUsername, remoteHost, 22);
+            session.setPassword(remotePassword);
+            session.setConfig("StrictHostKeyChecking", "no");
+            session.connect();
+            channelSftp = (ChannelSftp) session.openChannel("sftp");
+            channelSftp.connect();
+            // 创建远程目录（如果不存在）
+            try {
+                channelSftp.cd(remoteDirectory);
+            } catch (SftpException e) {
+                channelSftp.mkdir(remoteDirectory);
+                channelSftp.cd(remoteDirectory);
+            }
+            // 上传本地文件到远程服务器指定目录
+            for (String localFilePath : localFilePaths) {
+                uploadFileWithProgress(channelSftp, localFilePath, remoteDirectory);
+            }
+            channelSftp.disconnect();
+            // 执行远程命令启动jar包
+            log.info("Command:"+remoteStartCommand);
+            ChannelExec channelExec = (ChannelExec) session.openChannel("exec");
+            channelExec.setCommand(remoteStartCommand);
+            ByteArrayOutputStream commandOutput = new ByteArrayOutputStream();
+            channelExec.setOutputStream(commandOutput);
+            channelExec.connect();
+            // 使用新线程读取并打印命令输出
+            Thread outputThread = new Thread(() -> {
+                try (BufferedReader reader = new BufferedReader(new InputStreamReader(channelExec.getInputStream()))) {
+                    String line;
+                    while ((line = reader.readLine()) != null) {
+                        System.out.println(line);
+                    }
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            });
+            outputThread.start();
+            // 等待命令执行完成
+            while (!channelExec.isClosed()) {
+                Thread.sleep(1000);
+            }
+            // 等待命令输出线程结束
+            outputThread.join();
+            channelExec.disconnect();
+            log.info("=================End");
+        } catch (JSchException | SftpException | InterruptedException | IOException e) {
+            e.printStackTrace();
+        } finally {
+            if (channelSftp != null) {
+                channelSftp.disconnect();
+            }
+            if (session != null) {
+                session.disconnect();
+            }
+        }
+    }
+
+    private static void uploadFileWithProgress(ChannelSftp channelSftp, String localFilePath, String remoteDirectory) throws SftpException, IOException {
+        File file = new File(localFilePath);
+        String fileName = file.getName();
+        String remoteFilePath = remoteDirectory + File.separator + fileName;
+        AtomicLong uploadedSize = new AtomicLong();
+        try (InputStream inputStream = new FileInputStream(file)) {
+            // 如果远程目录已经存在同名文件，则先备份原文件
+            if (fileExists(channelSftp, remoteFilePath)) {
+                backupRemoteFile(channelSftp, remoteFilePath);
+            }
+            channelSftp.put(inputStream, remoteFilePath, new SftpProgressMonitor() {
+                @Override
+                public void init(int op, String src, String dest, long max) {
+                    // 初始化回调函数，可以做一些准备工作
+                }
+                @Override
+                public void end() {
+                    // 上传结束回调函数，可以做一些清理工作
+                }
+                @Override
+                public boolean count(long count) {
+                    uploadedSize.addAndGet(count);
+                    // 计算上传进度
+                    int progress = (int) ((uploadedSize.get() * 100) / file.length());
+
+                    // 每上传 10% 显示一次进度，可根据实际情况调整
+                    if (progress % 10 == 0) {
+                        log.info(fileName+"-----Upload progress: " + progress + "%");
+                    }
+                    // 返回 true 则继续传输，否则中止传输
+                    return true;
+                }
+            }, ChannelSftp.RESUME);
+        }
+    }
+
+    private static boolean fileExists(ChannelSftp channelSftp, String remoteFilePath) {
+        try {
+            channelSftp.lstat(remoteFilePath);
+            return true;
+        } catch (SftpException e) {
+            return false;
+        }
+    }
+
+    private static void backupRemoteFile(ChannelSftp channelSftp, String remoteFilePath) throws SftpException {
+        LocalDateTime now = LocalDateTime.now();
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
+        String backupTime = now.format(formatter);
+        String backupFilePath = remoteFilePath + "." + backupTime;
+        channelSftp.rename(remoteFilePath, backupFilePath);
+        log.info("Remote file already exists. Backing up the original file as: " + backupFilePath);
+    }
+}
+
+
+
@@ -0,0 +1,122 @@
+package org.dromara.neutrinoproxy.client.starter.util;
+
+import com.jcraft.jsch.*;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.nio.file.Paths;
+import java.util.Scanner;
+/**
+ * 简易ssh客户端
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+public class SSHClient {
+
+    private static final String COMMAND_UPLOAD = "upload";
+    private Session session;
+
+    public void connect(String remoteHost, String remoteUsername, String remotePassword) {
+        JSch jsch = new JSch();
+        try {
+            session = jsch.getSession(remoteUsername, remoteHost, 22);
+            session.setPassword(remotePassword);
+            session.setConfig("StrictHostKeyChecking", "no");
+            session.connect();
+            System.out.println("Connected to " + remoteHost);
+        } catch (JSchException e) {
+            e.printStackTrace();
+        }
+    }
+    public void startShell() {
+        if (session == null || !session.isConnected()) {
+            System.out.println("Not connected to a remote host");
+            return;
+        }
+        Channel channel;
+        try {
+            channel = session.openChannel("shell");
+            channel.connect();
+            Scanner scanner = new Scanner(System.in);
+            String line;
+            while (true) {
+                System.out.print("$ ");
+                line = scanner.nextLine();
+                if (line.equals("exit")) {
+                    break;
+                } else if (line.startsWith(COMMAND_UPLOAD)) {
+                    processUploadCommand(line);
+                } else {
+                    System.out.println("Executing command: " + line);
+                    executeCommand(line);
+                }
+            }
+        } catch (JSchException e) {
+            e.printStackTrace();
+        }finally {
+            disconnect();
+        }
+    }
+
+    public void disconnect() {
+        if (session != null && session.isConnected()) {
+            session.disconnect();
+            System.out.println("Disconnected from remote host");
+        }
+    }
+
+    private void processUploadCommand(String command) {
+        String[] parts = command.split("\\s+");
+        if (parts.length < 3) {
+            System.out.println("Invalid upload command");
+            return;
+        }
+        String localFilePath = parts[1];
+        String remoteDirectory = parts[2];
+        String remoteFilename = Paths.get(localFilePath).getFileName().toString();
+        if (parts.length >= 4) {
+            remoteFilename = parts[3];
+        }
+        uploadFile(localFilePath, remoteDirectory, remoteFilename);
+    }
+
+    private void uploadFile(String localFilePath, String remoteDirectory, String remoteFilename) {
+        ChannelSftp channelSftp = null;
+        try {
+            channelSftp = (ChannelSftp) session.openChannel("sftp");
+            channelSftp.connect();
+            channelSftp.cd(remoteDirectory);
+            System.out.println("Uploading file: " + localFilePath + " to: " + remoteDirectory + "/" + remoteFilename);
+            channelSftp.put(localFilePath, remoteFilename);
+            System.out.println("File uploaded successfully");
+        } catch (JSchException | SftpException e) {
+            e.printStackTrace();
+        } finally {
+            if (channelSftp != null) {
+                channelSftp.disconnect();
+            }
+        }
+    }
+    private void executeCommand(String command) {
+        ChannelExec channelExec = null;
+
+        try {
+            channelExec = (ChannelExec) session.openChannel("exec");
+            channelExec.setCommand(command);
+            BufferedReader in = new BufferedReader(new InputStreamReader(channelExec.getInputStream()));
+            channelExec.connect();
+            String line;
+            while ((line = in.readLine()) != null) {
+                System.out.println(line);
+            }
+            channelExec.disconnect();
+        } catch (JSchException | IOException e) {
+            e.printStackTrace();
+        } finally {
+            if (channelExec != null) {
+                channelExec.disconnect();
+            }
+        }
+    }
+}
@@ -0,0 +1,61 @@
+server:
+  port: 8201
+spring:
+  application:
+    name: neutrino-proxy-client
+neutrino:
+  proxy:
+    protocol:
+      max-frame-length: 2097152
+      length-field-offset: 0
+      length-field-length: 4
+      initial-bytes-to-strip: 0
+      length-adjustment: 0
+      read-idle-time: 120
+      write-idle-time: 20
+      all-idle-time-seconds: 0
+    tunnel:
+      # 线程池相关配置，用于技术调优，可忽略
+      thread-count: 50
+      # 隧道SSL证书配置
+      key-store-password: ${STORE_PASS:123456}
+      jks-path: ${JKS_PATH:classpath:/test.jks}
+      # 服务端IP
+      server-ip: ${SERVER_IP:}
+      # 服务端端口(对应服务端app.yml中的tunnel.port、tunnel.ssl-port)
+      server-port: ${SERVER_PORT:9002}
+      # 是否启用SSL(注意：该配置必须和server-port对应上)
+      ssl-enable: ${SSL_ENABLE:true}
+      # 客户端连接唯一凭证
+      license-key: ${LICENSE_KEY:}
+      # 客户端唯一身份标识（可忽略，若不设置首次启动会自动生成）
+      client-id: ${CLIENT_ID:}
+      # 是否开启隧道传输报文日志(日志级别为debug时开启才有效)
+      transfer-log-enable: ${CLIENT_LOG:false}
+      # 是否开启心跳日志
+      heartbeat-log-enable: ${HEARTBEAT_LOG:false}
+      # 重连设置
+      reconnection:
+        # 重连间隔（秒）
+        interval-seconds: 10
+        # 是否开启无限重连(未开启时，客户端license不合法会自动停止应用，开启了则不会，请谨慎开启)
+        unlimited: false
+    client:
+      udp:
+        # 线程池相关配置，用于技术调优，可忽略
+        boss-thread-count: 5
+        work-thread-count: 20
+        # udp傀儡端口范围
+        puppet-port-range: 10000-10500
+        # 是否开启隧道传输报文日志(日志级别为debug时开启才有效)
+        transfer-log-enable: ${CLIENT_LOG:false}
+    enable: true
+    sshEnable: false
+    sshProxys[0]:
+      host:
+      username:
+      password:
+      localPort:
+      remotePort:
+      remoteHost:
+
@@ -50,7 +50,7 @@
        :hide-on-single-pageInfo="false"
        @size-change="handleSizeChange"
        @current-change="handleCurrentChange"
-        :current-pageInfo="PaginationData.currentPage"
+        :current-page="PaginationData.currentPage"
        :pageInfo-sizes="[10, 20, 50, 100]"
        :pageInfo-size="PaginationData.pageSize"
        layout="total, sizes, prev, pager, next, jumper"
@@ -51,7 +51,7 @@
      </el-table-column>
    </el-table>
    <div class="pagination-container">
-      <el-pagination background @size-change="handleSizeChange" @current-change="handleCurrentChange" :current-pageInfo.sync="listQuery.current"
+      <el-pagination background @size-change="handleSizeChange" @current-change="handleCurrentChange" :current-page.sync="listQuery.current"
                     :pageInfo-sizes="[10,20,30, 50]" :pageInfo-size="listQuery.size" layout="total, sizes, prev, pager, next, jumper" :total="total">
      </el-pagination>
    </div>
@@ -58,7 +58,7 @@

    <div class="pagination-container">
      <el-pagination background @size-change="handleSizeChange" @current-change="handleCurrentChange"
-                     :current-pageInfo.sync="listQuery.current"
+                     :current-page.sync="listQuery.current"
                     :pageInfo-sizes="[10,20,30, 50]" :pageInfo-size="listQuery.size"
                     layout="total, sizes, prev, pager, next, jumper" :total="total">
      </el-pagination>
@@ -55,7 +55,7 @@
    </el-table>

    <div class="pagination-container">
-      <el-pagination background @size-change="handleSizeChange" @current-change="handleCurrentChange" :current-pageInfo.sync="listQuery.current"
+      <el-pagination background @size-change="handleSizeChange" @current-change="handleCurrentChange" :current-page.sync="listQuery.current"
                     :pageInfo-sizes="[10,20,30, 50]" :pageInfo-size="listQuery.size" layout="total, sizes, prev, pager, next, jumper" :total="total">
      </el-pagination>
    </div>
@@ -80,7 +80,7 @@

    <div class="pagination-container">
      <el-pagination background @size-change="handleSizeChange" @current-change="handleCurrentChange"
-                     :current-pageInfo.sync="listQuery.current" :pageInfo-sizes="[10, 20, 30, 50]" :pageInfo-size="listQuery.size"
+                     :current-page.sync="listQuery.current" :pageInfo-sizes="[10, 20, 30, 50]" :pageInfo-size="listQuery.size"
                     layout="total, sizes, prev, pager, next, jumper" :total="total">
      </el-pagination>
    </div>
@@ -176,7 +176,7 @@

      <div class="pagination-container">
        <el-pagination background @size-change="handlePortMappingSizeChange" @current-change="handlePortMappingCurrentChange"
-          :current-pageInfo.sync="portMappingListQuery.current" :pageInfo-sizes="[10, 20, 30, 50]" :pageInfo-size="portMappingListQuery.size"
+          :current-page.sync="portMappingListQuery.current" :pageInfo-sizes="[10, 20, 30, 50]" :pageInfo-size="portMappingListQuery.size"
          layout="total, sizes, prev, pager, next, jumper" :total="portMappingTotal">
        </el-pagination>
      </div>
@@ -81,7 +81,7 @@

    <div class="pagination-container">
      <el-pagination background @size-change="handleSizeChange" @current-change="handleCurrentChange"
-                     :current-pageInfo.sync="listQuery.current" :pageInfo-sizes="[10, 20, 30, 50]" :pageInfo-size="listQuery.size"
+                     :current-page.sync="listQuery.current" :pageInfo-sizes="[10, 20, 30, 50]" :pageInfo-size="listQuery.size"
                     layout="total, sizes, prev, pager, next, jumper" :total="total">
      </el-pagination>
    </div>
@@ -50,7 +50,7 @@
    </el-table>

    <div class="pagination-container">
-      <el-pagination background @size-change="handleSizeChange" @current-change="handleCurrentChange" :current-pageInfo.sync="listQuery.current"
+      <el-pagination background @size-change="handleSizeChange" @current-change="handleCurrentChange" :current-page.sync="listQuery.current"
                     :pageInfo-sizes="[10,20,30, 50]" :pageInfo-size="listQuery.size" layout="total, sizes, prev, pager, next, jumper" :total="total">
      </el-pagination>
    </div>
@@ -0,0 +1,16 @@
+FROM openjdk:21-jdk-oracle
+#同步时间
+#RUN sed -i 's/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g' /etc/apk/repositories && \
+#    apk update && apk add wget unzip vim && apk add -U tzdata && \
+#    ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && echo 'Asia/Shanghai' >/etc/timezone
+# 设置时区为北京时间
+ENV TZ=Asia/Shanghai
+RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+RUN mkdir -p /root/neutrino-proxy/config
+WORKDIR /root/neutrino-proxy
+COPY ./target/neutrino-proxy-client.jar /root/neutrino-proxy/neutrino-proxy-client.jar
+COPY ./src/main/resources/app-copy.yml /root/neutrino-proxy/config/app.yml
+#VOLUME ["/root/neutrino-proxy"]
+ENTRYPOINT ["java","-jar","neutrino-proxy-client.jar","config=./config/app.yml"]
+
+#docker run -it -d --restart=always --name np_client -e SERVER_IP=127.0.0.1
@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>neutrino-proxy</artifactId>
+        <groupId>org.dromara.neutrino-proxy</groupId>
+        <version>${revision}</version>
+        <relativePath>../pom.xml</relativePath>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>neutrino-proxy-client-sdk</artifactId>
+    <version>${revision}</version>
+    <packaging>jar</packaging>
+    <properties>
+        <revision>2.0.1</revision>
+<!--        <lombok.version>1.18.30</lombok.version>-->
+        <hutool.version>5.8.20</hutool.version>
+    </properties>
+    <dependencies>
+        <dependency>
+            <groupId>org.dromara.neutrino-proxy</groupId>
+            <artifactId>neutrino-proxy-core</artifactId>
+            <version>${revision}</version>
+<!--            <exclusions>-->
+<!--                <exclusion>-->
+<!--                    <groupId>org.noear</groupId>-->
+<!--                    <artifactId>solon-test</artifactId>-->
+<!--                </exclusion>-->
+<!--                <exclusion>-->
+<!--                    <groupId>org.noear</groupId>-->
+<!--                    <artifactId>solon.aot</artifactId>-->
+<!--                </exclusion>-->
+<!--                <exclusion>-->
+<!--                    <groupId>org.noear</groupId>-->
+<!--                    <artifactId>solon.logging.logback</artifactId>-->
+<!--                </exclusion>-->
+<!--                <exclusion>-->
+<!--                    <groupId>cn.hutool</groupId>-->
+<!--                    <artifactId>hutool-core</artifactId>-->
+<!--                </exclusion>-->
+<!--                <exclusion>-->
+<!--                    <groupId>cn.hutool</groupId>-->
+<!--                    <artifactId>hutool-cache</artifactId>-->
+<!--                </exclusion>-->
+<!--            </exclusions>-->
+        </dependency>
+<!--        <dependency>-->
+<!--            <groupId>org.projectlombok</groupId>-->
+<!--            <artifactId>lombok</artifactId>-->
+<!--            <scope>${lombok.version}</scope>-->
+<!--        </dependency>-->
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-slf4j-impl</artifactId>
+            <version>2.20.0</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>${hutool.version}</version>
+        </dependency>
+
+    </dependencies>
+
+    <build>
+        <finalName>${project.artifactId}</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+                <includes>
+                    <include>*.yml</include>
+                </includes>
+            </resource>
+            <resource>
+                <directory>${project.basedir}/src/main/resources</directory>
+                <filtering>false</filtering>
+
+                <excludes>
+                    <exclude>app-dev.yml</exclude>
+                </excludes>
+            </resource>
+        </resources>
+<!--        <plugins>-->
+<!--            &lt;!&ndash; 配置打包插件（并打包成胖包） &ndash;&gt;-->
+<!--            <plugin>-->
+<!--                <groupId>org.noear</groupId>-->
+<!--                <artifactId>solon-maven-plugin</artifactId>-->
+<!--            </plugin>-->
+<!--        </plugins>-->
+    </build>
+
+</project>
@@ -0,0 +1,185 @@
+package org.dromara.neutrinoproxy.client.sdk.config;
+
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelOption;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioDatagramChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.handler.logging.LoggingHandler;
+import io.netty.handler.timeout.IdleStateHandler;
+import org.dromara.neutrinoproxy.client.sdk.core.*;
+import org.dromara.neutrinoproxy.client.sdk.util.ProxyUtil;
+import org.dromara.neutrinoproxy.core.ProxyMessageDecoder;
+import org.dromara.neutrinoproxy.core.ProxyMessageEncoder;
+
+import java.net.InetSocketAddress;
+
+/**
+ * 代理配置
+ * @author: aoshiguchen
+ * @date: 2022/10/8
+ */
+
+public abstract class IProxyConfiguration {
+
+
+    public NioEventLoopGroup tunnelWorkGroup(ProxyConfig proxyConfig) {
+        return new NioEventLoopGroup(proxyConfig.getTunnel().getThreadCount());
+    }
+
+    public NioEventLoopGroup tcpRealServerWorkGroup(ProxyConfig proxyConfig) {
+        // 暂时先公用此配置
+        return new NioEventLoopGroup(proxyConfig.getTunnel().getThreadCount());
+    }
+
+    public NioEventLoopGroup udpServerGroup(ProxyConfig proxyConfig) {
+        // 暂时先公用此配置
+        return new NioEventLoopGroup(proxyConfig.getClient().getUdp().getBossThreadCount());
+    }
+
+    public NioEventLoopGroup udpWorkGroup(ProxyConfig proxyConfig) {
+        // 暂时先公用此配置
+        return new NioEventLoopGroup(proxyConfig.getClient().getUdp().getWorkThreadCount());
+    }
+
+    public Bootstrap cmdTunnelBootstrap(ProxyConfig proxyConfig,
+                                        NioEventLoopGroup tunnelWorkGroup) {
+        Bootstrap bootstrap = new Bootstrap();
+        bootstrap.group(tunnelWorkGroup);
+        bootstrap.channel(NioSocketChannel.class);
+//		bootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000);
+//		bootstrap.option(ChannelOption.SO_KEEPALIVE, true);
+//		/**
+//		 * TCP/IP协议中，无论发送多少数据，总是要在数据前面加上协议头，同时，对方接收到数据，也需要发送ACK表示确认。为了尽可能的利用网络带宽，TCP总是希望尽可能的发送足够大的数据。（一个连接会设置MSS参数，因此，TCP/IP希望每次都能够以MSS尺寸的数据块来发送数据）。
+//		 * Nagle算法就是为了尽可能发送大块数据，避免网络中充斥着许多小数据块。
+//		 */
+//		bootstrap.option(ChannelOption.TCP_NODELAY, true);
+        bootstrap.remoteAddress(InetSocketAddress.createUnresolved(proxyConfig.getTunnel().getServerIp(), proxyConfig.getTunnel().getServerPort()));
+
+        bootstrap.handler(new ChannelInitializer<SocketChannel>() {
+
+            @Override
+            public void initChannel(SocketChannel ch) throws Exception {
+                if (proxyConfig.getTunnel().getSslEnable()) {
+                    ch.pipeline().addLast(ProxyUtil.createSslHandler(proxyConfig));
+                }
+                if (null != proxyConfig.getTunnel().getTransferLogEnable() && proxyConfig.getTunnel().getTransferLogEnable()) {
+                    ch.pipeline().addFirst(new LoggingHandler(CmdChannelHandler.class));
+                }
+                ch.pipeline().addLast(new ProxyMessageDecoder(proxyConfig.getProtocol().getMaxFrameLength(),
+                        proxyConfig.getProtocol().getLengthFieldOffset(), proxyConfig.getProtocol().getLengthFieldLength(),
+                        proxyConfig.getProtocol().getLengthAdjustment(), proxyConfig.getProtocol().getInitialBytesToStrip()));
+                ch.pipeline().addLast(new ProxyMessageEncoder());
+                ch.pipeline().addLast(new IdleStateHandler(proxyConfig.getProtocol().getReadIdleTime(), proxyConfig.getProtocol().getWriteIdleTime(), proxyConfig.getProtocol().getAllIdleTimeSeconds()));
+                ch.pipeline().addLast(new CmdChannelHandler());
+            }
+        });
+        return bootstrap;
+    }
+
+    public Bootstrap tcpProxyTunnelBootstrap(ProxyConfig proxyConfig,
+                                             NioEventLoopGroup tunnelWorkGroup) {
+        Bootstrap bootstrap = new Bootstrap();
+        bootstrap.group(tunnelWorkGroup);
+        bootstrap.channel(NioSocketChannel.class);
+        bootstrap.remoteAddress(InetSocketAddress.createUnresolved(proxyConfig.getTunnel().getServerIp(), proxyConfig.getTunnel().getServerPort()));
+        bootstrap.handler(new ChannelInitializer<SocketChannel>() {
+
+            @Override
+            public void initChannel(SocketChannel ch) throws Exception {
+                if (proxyConfig.getTunnel().getSslEnable()) {
+                    ch.pipeline().addLast(ProxyUtil.createSslHandler(proxyConfig));
+                }
+                if (null != proxyConfig.getTunnel().getTransferLogEnable() && proxyConfig.getTunnel().getTransferLogEnable()) {
+                    ch.pipeline().addFirst(new LoggingHandler(TcpProxyChannelHandler.class));
+                }
+                ch.pipeline().addLast(new ProxyMessageDecoder(proxyConfig.getProtocol().getMaxFrameLength(),
+                        proxyConfig.getProtocol().getLengthFieldOffset(), proxyConfig.getProtocol().getLengthFieldLength(),
+                        proxyConfig.getProtocol().getLengthAdjustment(), proxyConfig.getProtocol().getInitialBytesToStrip()));
+                ch.pipeline().addLast(new ProxyMessageEncoder());
+                ch.pipeline().addLast(new IdleStateHandler(proxyConfig.getProtocol().getReadIdleTime(), proxyConfig.getProtocol().getWriteIdleTime(), proxyConfig.getProtocol().getAllIdleTimeSeconds()));
+                ch.pipeline().addLast(new TcpProxyChannelHandler());
+            }
+        });
+        return bootstrap;
+    }
+    public Bootstrap udpProxyTunnelBootstrap(ProxyConfig proxyConfig,
+                                              NioEventLoopGroup tunnelWorkGroup) {
+        Bootstrap bootstrap = new Bootstrap();
+        bootstrap.group(tunnelWorkGroup);
+        bootstrap.channel(NioSocketChannel.class);
+        bootstrap.remoteAddress(InetSocketAddress.createUnresolved(proxyConfig.getTunnel().getServerIp(), proxyConfig.getTunnel().getServerPort()));
+        bootstrap.handler(new ChannelInitializer<SocketChannel>() {
+
+            @Override
+            public void initChannel(SocketChannel ch) throws Exception {
+                if (proxyConfig.getTunnel().getSslEnable()) {
+                    ch.pipeline().addLast(ProxyUtil.createSslHandler(proxyConfig));
+                }
+                if (null != proxyConfig.getTunnel().getTransferLogEnable() && proxyConfig.getTunnel().getTransferLogEnable()) {
+                    ch.pipeline().addFirst(new LoggingHandler(TcpProxyChannelHandler.class));
+                }
+                ch.pipeline().addLast(new ProxyMessageDecoder(proxyConfig.getProtocol().getMaxFrameLength(),
+                        proxyConfig.getProtocol().getLengthFieldOffset(), proxyConfig.getProtocol().getLengthFieldLength(),
+                        proxyConfig.getProtocol().getLengthAdjustment(), proxyConfig.getProtocol().getInitialBytesToStrip()));
+                ch.pipeline().addLast(new ProxyMessageEncoder());
+                ch.pipeline().addLast(new IdleStateHandler(proxyConfig.getProtocol().getReadIdleTime(), proxyConfig.getProtocol().getWriteIdleTime(), proxyConfig.getProtocol().getAllIdleTimeSeconds()));
+                ch.pipeline().addLast(new UdpProxyChannelHandler());
+            }
+        });
+        return bootstrap;
+    }
+
+    public Bootstrap realServerBootstrap(ProxyConfig proxyConfig,
+                                             NioEventLoopGroup tcpRealServerWorkGroup
+                                             ) {
+        Bootstrap bootstrap = new Bootstrap();
+        bootstrap.group(tcpRealServerWorkGroup);
+        bootstrap.channel(NioSocketChannel.class);
+        bootstrap.handler(new ChannelInitializer<SocketChannel>() {
+
+            @Override
+            public void initChannel(SocketChannel ch) throws Exception {
+                if (null != proxyConfig.getTunnel().getTransferLogEnable() && proxyConfig.getTunnel().getTransferLogEnable()) {
+                    ch.pipeline().addFirst(new LoggingHandler(RealServerChannelHandler.class));
+                }
+                ch.pipeline().addLast(new RealServerChannelHandler());
+            }
+        });
+        return bootstrap;
+    }
+
+    public Bootstrap udpServerBootstrap(ProxyConfig proxyConfig,
+                                        NioEventLoopGroup udpServerGroup,
+                                         NioEventLoopGroup udpWorkGroup) {
+        Bootstrap bootstrap = new Bootstrap();
+        bootstrap.group(udpServerGroup)
+                // 主线程处理
+                .channel(NioDatagramChannel.class)
+                // 广播
+                .option(ChannelOption.SO_BROADCAST, true)
+                // 设置读缓冲区为2M
+                .option(ChannelOption.SO_RCVBUF, 2048 * 1024)
+                // 设置写缓冲区为1M
+                .option(ChannelOption.SO_SNDBUF, 1024 * 1024)
+                .handler(new ChannelInitializer<NioDatagramChannel>() {
+                    @Override
+                    protected void initChannel(NioDatagramChannel ch) {
+                        ChannelPipeline pipeline = ch.pipeline();
+                        if (null != proxyConfig.getClient().getUdp().getTransferLogEnable() && proxyConfig.getClient().getUdp().getTransferLogEnable()) {
+                            ch.pipeline().addFirst(new LoggingHandler(UdpRealServerHandler.class));
+                        }
+                        pipeline.addLast(udpWorkGroup, new UdpRealServerHandler());
+                    }
+                });
+        return bootstrap;
+    }
+
+//    public NeutrinoCoreRuntimeNativeRegistrar neutrinoCoreRuntimeNativeRegistrar() {
+//        return new NeutrinoCoreRuntimeNativeRegistrar();
+//    }
+
+}
@@ -1,8 +1,6 @@
-package org.dromara.neutrinoproxy.client.config;
+package org.dromara.neutrinoproxy.client.sdk.config;

 import lombok.Data;
-import org.noear.solon.annotation.Component;
-import org.noear.solon.annotation.Inject;

 /**
 *
@@ -10,13 +8,9 @@ import org.noear.solon.annotation.Inject;
 * @date: 2022/6/16
 */
@Data
-@Component
 public class ProxyConfig {
-	@Inject("${neutrino.proxy.protocol}")
 	private Protocol protocol;
-	@Inject("${neutrino.proxy.tunnel}")
 	private Tunnel tunnel;
-	@Inject("${neutrino.proxy.client}")
 	private Client client;

 	@Data
@@ -1,7 +1,7 @@
-package org.dromara.neutrinoproxy.client.constant;
+package org.dromara.neutrinoproxy.client.sdk.constant;

 import io.netty.util.AttributeKey;
-import org.dromara.neutrinoproxy.client.util.UdpChannelBindInfo;
+import org.dromara.neutrinoproxy.client.sdk.util.UdpChannelBindInfo;

 /**
 * @author: aoshiguchen
@@ -1,17 +1,17 @@
-package org.dromara.neutrinoproxy.client.core;
+package org.dromara.neutrinoproxy.client.sdk.core;

-import org.dromara.neutrinoproxy.client.config.ProxyConfig;
-import org.dromara.neutrinoproxy.client.util.ProxyUtil;
-import org.dromara.neutrinoproxy.core.Constants;
-import org.dromara.neutrinoproxy.core.ProxyMessage;
-import org.dromara.neutrinoproxy.core.dispatcher.Dispatcher;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelOption;
 import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.handler.timeout.IdleStateEvent;
 import lombok.extern.slf4j.Slf4j;
-import org.noear.solon.Solon;
+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
+import org.dromara.neutrinoproxy.client.sdk.handler.ProxyMessageFactory;
+import org.dromara.neutrinoproxy.client.sdk.util.ProxyUtil;
+import org.dromara.neutrinoproxy.core.Constants;
+import org.dromara.neutrinoproxy.core.ProxyMessage;
+import org.dromara.neutrinoproxy.core.dispatcher.Dispatcher;

 /**
 * 处理与服务端之间的数据传输
@@ -19,22 +19,25 @@ import org.noear.solon.Solon;
 * @date: 2022/6/16
 */
@Slf4j
-public class CmdChannelHandler extends SimpleChannelInboundHandler<ProxyMessage> {
+public class CmdChannelHandler extends SimpleChannelInboundHandler<ProxyMessage>{
    private static volatile Boolean transferLogEnable = Boolean.FALSE;

+
    public CmdChannelHandler() {
-        ProxyConfig proxyConfig = Solon.context().getBean(ProxyConfig.class);
+        ProxyConfig proxyConfig = (ProxyConfig) ProxyMessageFactory.beanManager.get("proxyConfig").getBean();
        if (null != proxyConfig.getClient() && null != proxyConfig.getTunnel().getHeartbeatLogEnable()) {
            transferLogEnable = proxyConfig.getTunnel().getHeartbeatLogEnable();
        }
    }

    @Override
-    protected void channelRead0(ChannelHandlerContext ctx, ProxyMessage proxyMessage) throws Exception {
+    protected void channelRead0(ChannelHandlerContext ctx, ProxyMessage proxyMessage){
        if (ProxyMessage.TYPE_HEARTBEAT != proxyMessage.getType() || transferLogEnable) {
            log.debug("[CMD Channel]Client CmdChannel recieved proxy message, type is {}", proxyMessage.getType());
        }
-        Solon.context().getBean(Dispatcher.class).dispatch(ctx, proxyMessage);
+//        beanHandler.getDispatcher().dispatch(ctx, proxyMessage);
+        Dispatcher dispatcher = (Dispatcher) ProxyMessageFactory.beanManager.get("dispatcher").getBean();
+        dispatcher.dispatch(ctx,proxyMessage);
    }

    @Override
@@ -57,13 +60,13 @@ public class CmdChannelHandler extends SimpleChannelInboundHandler<ProxyMessage>
    }

    @Override
-    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause){
        log.error("[CMD Channel]Client CmdChannel Error channelId:{}", ctx.channel().id().asLongText(), cause);
        ctx.close();
    }

    @Override
-    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+    public void userEventTriggered(ChannelHandlerContext ctx, Object evt){
        if(evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent)evt;
            switch (event.state()) {
@@ -82,4 +85,5 @@ public class CmdChannelHandler extends SimpleChannelInboundHandler<ProxyMessage>
            }
        }
    }
+
 }
@@ -19,7 +19,7 @@
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
-package org.dromara.neutrinoproxy.client.core;
+package org.dromara.neutrinoproxy.client.sdk.core;

 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -35,9 +35,7 @@ public class CustomThreadFactory implements ThreadFactory {
 	private final String namePrefix;

 	public CustomThreadFactory(String prefix) {
-		SecurityManager s = System.getSecurityManager();
-		group = (s != null) ? s.getThreadGroup() :
-			Thread.currentThread().getThreadGroup();
+		group = Thread.currentThread().getThreadGroup();
 		namePrefix = prefix + "-thread-";
 	}

@@ -0,0 +1,126 @@
+package org.dromara.neutrinoproxy.client.sdk.core;
+
+import cn.hutool.core.util.StrUtil;
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelFutureListener;
+import lombok.Data;
+import lombok.extern.slf4j.Slf4j;
+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
+import org.dromara.neutrinoproxy.client.sdk.util.ProxyUtil;
+import org.dromara.neutrinoproxy.client.sdk.util.UdpServerUtil;
+import org.dromara.neutrinoproxy.core.ProxyMessage;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+/**
+ * 代理客户端服务
+ * @author: aoshiguchen
+ * @date: 2022/6/16
+ */
+@Slf4j
+@Data
+public class IAbProxyClientService {
+
+    public ProxyConfig proxyConfig;
+
+    public Bootstrap cmdTunnelBootstrap;
+
+    public Bootstrap udpServerBootstrap;
+
+    public Boolean isAotRuntime;
+
+    private volatile Channel channel;
+    /**
+     * 重连次数
+     */
+    private volatile int reconnectCount = 0;
+
+	/**
+	 * 重连服务执行器
+	 */
+    public static final ScheduledExecutorService reconnectExecutor = Executors.newSingleThreadScheduledExecutor(new CustomThreadFactory("ClientReconnect"));
+
+    public void init(){
+        reconnectExecutor.scheduleWithFixedDelay(this::reconnect, 10, proxyConfig.getTunnel().getReconnection().getIntervalSeconds(), TimeUnit.SECONDS);
+        try {
+            this.start();
+            UdpServerUtil.initCache(proxyConfig, udpServerBootstrap,isAotRuntime);
+        } catch (Exception e) {
+            // 启动连不上也做一下重连，因此先catch异常
+            log.error("[CmdChannel] start error", e);
+        }
+    }
+
+	public void start() {
+		if (StrUtil.isEmpty(proxyConfig.getTunnel().getServerIp())) {
+			log.error("not found server-ip config.");
+			return;
+		}
+		if (null == proxyConfig.getTunnel().getServerPort()) {
+			log.error("not found server-port config.");
+			return;
+		}
+		if (null != proxyConfig.getTunnel().getSslEnable() && proxyConfig.getTunnel().getSslEnable()
+				&& StrUtil.isEmpty(proxyConfig.getTunnel().getJksPath())) {
+			log.error("not found jks-path config.");
+			return;
+		}
+		if (StrUtil.isEmpty(proxyConfig.getTunnel().getLicenseKey())) {
+			log.error("not found license-key config.");
+			return;
+		}
+		if (null == channel || !channel.isActive()) {
+			try {
+				connectProxyServer();
+			} catch (Exception e) {
+				log.error("client start error", e);
+			}
+		} else {
+			channel.writeAndFlush(ProxyMessage.buildAuthMessage(proxyConfig.getTunnel().getLicenseKey(), ProxyUtil.getClientId(proxyConfig)));
+		}
+	}
+
+	/**
+	 * 连接代理服务器
+	 */
+	private void connectProxyServer() throws InterruptedException {
+		cmdTunnelBootstrap.connect()
+			.addListener(new ChannelFutureListener() {
+
+				@Override
+				public void operationComplete(ChannelFuture future) throws Exception {
+					if (future.isSuccess()) {
+						channel = future.channel();
+						// 连接成功，向服务器发送客户端认证信息（licenseKey）
+						ProxyUtil.setCmdChannel(future.channel());
+						future.channel().writeAndFlush(ProxyMessage.buildAuthMessage(proxyConfig.getTunnel().getLicenseKey(), ProxyUtil.getClientId(proxyConfig)));
+						log.info("[CmdChannel] connect proxy server {}:{} success. channelId:{}", proxyConfig.getTunnel().getServerIp(), proxyConfig.getTunnel().getServerPort(), future.channel().id().asLongText());
+
+//						reconnectServiceEnable = true;
+						reconnectCount = 0;
+					} else {
+						log.info("[CmdChannel] connect proxy server {}:{} failed!", proxyConfig.getTunnel().getServerIp(), proxyConfig.getTunnel().getServerPort());
+					}
+				}
+			}).sync();
+	}
+
+	protected synchronized void reconnect() {
+		if (null != channel) {
+			if (channel.isActive()) {
+				return;
+			}
+			channel.close();
+		}
+
+		log.info("[CmdChannel] client reconnect seq:{}", ++reconnectCount);
+		try {
+			connectProxyServer();
+		} catch (Exception e) {
+			log.error("[CmdChannel] reconnect error", e);
+		}
+	}
+}
@@ -20,7 +20,7 @@
 * SOFTWARE.
 */

-package org.dromara.neutrinoproxy.client.core;
+package org.dromara.neutrinoproxy.client.sdk.core;

 import io.netty.channel.Channel;

@@ -20,10 +20,10 @@
 * SOFTWARE.
 */

-package org.dromara.neutrinoproxy.client.core;
+package org.dromara.neutrinoproxy.client.sdk.core;

 import lombok.extern.slf4j.Slf4j;
-import org.dromara.neutrinoproxy.client.util.ProxyUtil;
+import org.dromara.neutrinoproxy.client.sdk.util.ProxyUtil;
 import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
 import io.netty.buffer.ByteBuf;
@@ -1,4 +1,4 @@
-package org.dromara.neutrinoproxy.client.core;
+package org.dromara.neutrinoproxy.client.sdk.core;

 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
@@ -6,11 +6,11 @@ import io.netty.channel.ChannelOption;
 import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.handler.timeout.IdleStateEvent;
 import lombok.extern.slf4j.Slf4j;
-import org.dromara.neutrinoproxy.client.util.ProxyUtil;
+import org.dromara.neutrinoproxy.client.sdk.handler.ProxyMessageFactory;
+import org.dromara.neutrinoproxy.client.sdk.util.ProxyUtil;
 import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
 import org.dromara.neutrinoproxy.core.dispatcher.Dispatcher;
-import org.noear.solon.Solon;

 /**
 * 处理与服务端之间的数据传输
@@ -26,7 +26,8 @@ public class TcpProxyChannelHandler extends SimpleChannelInboundHandler<ProxyMes
        if (ProxyMessage.TYPE_HEARTBEAT != proxyMessage.getType()) {
            log.debug("[TCP Proxy Channel]Client ProxyChannel recieved proxy message, type is {}", proxyMessage.getType());
        }
-        Solon.context().getBean(Dispatcher.class).dispatch(ctx, proxyMessage);
+        Dispatcher dispatcher = (Dispatcher) ProxyMessageFactory.beanManager.get("dispatcher").getBean();
+        dispatcher.dispatch(ctx,proxyMessage);
    }

    @Override
@@ -52,13 +53,13 @@ public class TcpProxyChannelHandler extends SimpleChannelInboundHandler<ProxyMes
    }

    @Override
-    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)  {
        log.error("[TCP Proxy Channel]Client ProxyChannel Error channelId:{}", ctx.channel().id().asLongText(), cause);
        ctx.close();
    }

    @Override
-    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+    public void userEventTriggered(ChannelHandlerContext ctx, Object evt)  {
        if(evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent)evt;
            switch (event.state()) {
@@ -1,4 +1,4 @@
-package org.dromara.neutrinoproxy.client.core;
+package org.dromara.neutrinoproxy.client.sdk.core;

 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
@@ -6,11 +6,11 @@ import io.netty.channel.ChannelOption;
 import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.handler.timeout.IdleStateEvent;
 import lombok.extern.slf4j.Slf4j;
-import org.dromara.neutrinoproxy.client.util.ProxyUtil;
+import org.dromara.neutrinoproxy.client.sdk.handler.ProxyMessageFactory;
+import org.dromara.neutrinoproxy.client.sdk.util.ProxyUtil;
 import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
 import org.dromara.neutrinoproxy.core.dispatcher.Dispatcher;
-import org.noear.solon.Solon;

 /**
 * 处理与服务端之间的数据传输
@@ -20,13 +20,13 @@ import org.noear.solon.Solon;
@Slf4j
 public class UdpProxyChannelHandler extends SimpleChannelInboundHandler<ProxyMessage> {

-
    @Override
-    protected void channelRead0(ChannelHandlerContext ctx, ProxyMessage proxyMessage) throws Exception {
+    protected void channelRead0(ChannelHandlerContext ctx, ProxyMessage proxyMessage)  {
        if (ProxyMessage.TYPE_HEARTBEAT != proxyMessage.getType()) {
            log.debug("[UDP Proxy Channel]Client ProxyChannel recieved proxy message, type is {}", proxyMessage.getType());
        }
-        Solon.context().getBean(Dispatcher.class).dispatch(ctx, proxyMessage);
+        Dispatcher dispatcher = (Dispatcher) ProxyMessageFactory.beanManager.get("dispatcher").getBean();
+        dispatcher.dispatch(ctx,proxyMessage);
    }

    @Override
@@ -52,13 +52,13 @@ public class UdpProxyChannelHandler extends SimpleChannelInboundHandler<ProxyMes
    }

    @Override
-    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)  {
        log.error("[UDP Proxy Channel]Client ProxyChannel Error channelId:{}", ctx.channel().id().asLongText(), cause);
        ctx.close();
    }

    @Override
-    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+    public void userEventTriggered(ChannelHandlerContext ctx, Object evt)  {
        if(evt instanceof IdleStateEvent) {
            IdleStateEvent event = (IdleStateEvent)evt;
            switch (event.state()) {
@@ -1,11 +1,11 @@
-package org.dromara.neutrinoproxy.client.core;
+package org.dromara.neutrinoproxy.client.sdk.core;

 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.channel.socket.DatagramPacket;
 import lombok.extern.slf4j.Slf4j;
-import org.dromara.neutrinoproxy.client.constant.Constants;
-import org.dromara.neutrinoproxy.client.util.UdpChannelBindInfo;
+import org.dromara.neutrinoproxy.client.sdk.constant.Constants;
+import org.dromara.neutrinoproxy.client.sdk.util.UdpChannelBindInfo;
 import org.dromara.neutrinoproxy.core.ProxyMessage;

 import java.net.InetSocketAddress;
@@ -1,17 +1,15 @@
-package org.dromara.neutrinoproxy.client.handler;
+package org.dromara.neutrinoproxy.client.sdk.handler;

+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
 import io.netty.channel.ChannelHandlerContext;
 import lombok.extern.slf4j.Slf4j;
-import org.dromara.neutrinoproxy.client.config.ProxyConfig;
+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
 import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.ExceptionEnum;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
 import org.dromara.neutrinoproxy.core.ProxyMessageHandler;
 import org.dromara.neutrinoproxy.core.dispatcher.Match;
-import org.noear.snack.ONode;
-import org.noear.solon.Solon;
-import org.noear.solon.annotation.Component;
-import org.noear.solon.annotation.Inject;

 /**
 * 认证信息处理器
@@ -20,22 +18,26 @@ import org.noear.solon.annotation.Inject;
 */
@Slf4j
@Match(type = Constants.ProxyDataTypeName.AUTH)
-@Component
 public class ProxyMessageAuthHandler implements ProxyMessageHandler {
-	@Inject
-	private ProxyConfig proxyConfig;
+	private final ProxyConfig proxyConfig;
+    private final Runnable stop;
+
+    public ProxyMessageAuthHandler(ProxyConfig proxyConfig,Runnable stop){
+        this.proxyConfig=proxyConfig;
+        this.stop=stop;
+    }
 	@Override
 	public void handle(ChannelHandlerContext context, ProxyMessage proxyMessage) {
 		String info = proxyMessage.getInfo();
-        ONode load = ONode.load(info);
-        Integer code = load.get("code").getInt();
+        JSONObject load = JSONUtil.parseObj(info);
+        Integer code = load.getInt("code");
 		log.info("Auth result:{}", info);
 		if (ExceptionEnum.AUTH_FAILED.getCode().equals(code)) {
 			// 客户端认证失败，直接停止服务
 			log.info("client auth failed , client stop.");
 			context.channel().close();
 			if (!proxyConfig.getTunnel().getReconnection().getUnlimited()) {
-				Solon.stop();
+				stop.run();
 			}
 		} else if (ExceptionEnum.CONNECT_FAILED.getCode().equals(code) ||
 				ExceptionEnum.LICENSE_CANNOT_REPEAT_CONNECT.getCode().equals(code)
@@ -0,0 +1,86 @@
+package org.dromara.neutrinoproxy.client.sdk.handler;
+
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.*;
+import lombok.extern.slf4j.Slf4j;
+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
+import org.dromara.neutrinoproxy.client.sdk.core.ProxyChannelBorrowListener;
+import org.dromara.neutrinoproxy.client.sdk.util.ProxyUtil;
+import org.dromara.neutrinoproxy.core.Constants;
+import org.dromara.neutrinoproxy.core.ProxyDataTypeEnum;
+import org.dromara.neutrinoproxy.core.ProxyMessage;
+import org.dromara.neutrinoproxy.core.ProxyMessageHandler;
+import org.dromara.neutrinoproxy.core.dispatcher.Match;
+
+/**
+ * 连接信息处理器
+ * @author: aoshiguchen
+ * @date: 2022/6/16
+ */
+@Slf4j
+@Match(type = Constants.ProxyDataTypeName.CONNECT)
+public class ProxyMessageConnectHandler implements ProxyMessageHandler {
+
+	private final Bootstrap tcpProxyTunnelBootstrap;
+	private final Bootstrap realServerBootstrap;
+	private final ProxyConfig proxyConfig;
+
+    public ProxyMessageConnectHandler(Bootstrap tcpProxyTunnelBootstrap,Bootstrap realServerBootstrap,ProxyConfig proxyConfig){
+        this.proxyConfig=proxyConfig;
+        this.realServerBootstrap=realServerBootstrap;
+        this.tcpProxyTunnelBootstrap=tcpProxyTunnelBootstrap;
+    }
+
+	@Override
+	public void handle(ChannelHandlerContext ctx, ProxyMessage proxyMessage) {
+		final Channel cmdChannel = ctx.channel();
+		final String visitorId = proxyMessage.getInfo();
+		String[] serverInfo = new String(proxyMessage.getData()).split(":");
+		String ip = serverInfo[0];
+		int port = Integer.parseInt(serverInfo[1]);
+		// 连接真实的、被代理的服务
+		realServerBootstrap.connect(ip, port).addListener((ChannelFutureListener) future -> {
+            // 连接后端服务器成功
+            if (future.isSuccess()) {
+                final Channel realServerChannel = future.channel();
+
+                realServerChannel.config().setOption(ChannelOption.AUTO_READ, false);
+
+                // 获取连接
+                ProxyUtil.borrowTcpProxyChanel(tcpProxyTunnelBootstrap, new ProxyChannelBorrowListener() {
+
+                    @Override
+                    public void success(Channel channel) {
+                        // 连接绑定
+                        channel.attr(Constants.NEXT_CHANNEL).set(realServerChannel);
+                        realServerChannel.attr(Constants.NEXT_CHANNEL).set(channel);
+
+                        // 远程绑定
+                        channel.writeAndFlush(ProxyMessage.buildConnectMessage(visitorId + "@" + proxyConfig.getTunnel().getLicenseKey()));
+
+                        realServerChannel.config().setOption(ChannelOption.AUTO_READ, true);
+                        ProxyUtil.addRealServerChannel(visitorId, realServerChannel);
+                        ProxyUtil.setRealServerChannelVisitorId(realServerChannel, visitorId);
+                    }
+
+                    @Override
+                    public void error(Throwable cause) {
+                        ProxyMessage proxyMessage1 = new ProxyMessage();
+                        proxyMessage1.setType(ProxyMessage.TYPE_DISCONNECT);
+                        proxyMessage1.setInfo(visitorId);
+                        cmdChannel.writeAndFlush(proxyMessage1);
+                    }
+                });
+
+            } else {
+                cmdChannel.writeAndFlush(ProxyMessage.buildDisconnectMessage(visitorId));
+            }
+        });
+	}
+
+	@Override
+	public String name() {
+		return ProxyDataTypeEnum.CONNECT.getDesc();
+	}
+
+}
@@ -1,24 +1,24 @@
-package org.dromara.neutrinoproxy.client.handler;
+package org.dromara.neutrinoproxy.client.sdk.handler;

-import org.dromara.neutrinoproxy.client.util.ProxyUtil;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandlerContext;
+import lombok.extern.slf4j.Slf4j;
+import org.dromara.neutrinoproxy.client.sdk.util.ProxyUtil;
 import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.ProxyDataTypeEnum;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
 import org.dromara.neutrinoproxy.core.ProxyMessageHandler;
 import org.dromara.neutrinoproxy.core.dispatcher.Match;
-import io.netty.buffer.Unpooled;
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelFutureListener;
-import io.netty.channel.ChannelHandlerContext;
-import org.noear.solon.annotation.Component;

 /**
 * 断开连接信息处理器
 * @author: aoshiguchen
 * @date: 2022/6/16
 */
+@Slf4j
@Match(type = Constants.ProxyDataTypeName.DISCONNECT)
-@Component
 public class ProxyMessageDisconnectHandler implements ProxyMessageHandler {

 	@Override
@@ -1,15 +1,11 @@
-package org.dromara.neutrinoproxy.client.handler;
+package org.dromara.neutrinoproxy.client.sdk.handler;

+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
 import io.netty.channel.ChannelHandlerContext;
 import lombok.extern.slf4j.Slf4j;
-import org.dromara.neutrinoproxy.core.Constants;
-import org.dromara.neutrinoproxy.core.ExceptionEnum;
-import org.dromara.neutrinoproxy.core.ProxyDataTypeEnum;
-import org.dromara.neutrinoproxy.core.ProxyMessage;
-import org.dromara.neutrinoproxy.core.ProxyMessageHandler;
+import org.dromara.neutrinoproxy.core.*;
 import org.dromara.neutrinoproxy.core.dispatcher.Match;
-import org.noear.snack.ONode;
-import org.noear.solon.annotation.Component;

 /**
 * 异常信息处理器
@@ -18,14 +14,13 @@ import org.noear.solon.annotation.Component;
 */
@Slf4j
@Match(type = Constants.ProxyDataTypeName.ERROR)
-@Component
 public class ProxyMessageErrorHandler implements ProxyMessageHandler {

 	@Override
 	public void handle(ChannelHandlerContext ctx, ProxyMessage proxyMessage) {
 		log.info("error: {}", proxyMessage.getInfo());
-        ONode load = ONode.load(proxyMessage.getInfo());
-        Integer code = load.get("code").getInt();
+        JSONObject load = JSONUtil.parseObj(proxyMessage.getInfo());
+        Integer code = load.getInt("code");
 		if (ExceptionEnum.AUTH_FAILED.getCode().equals(code)) {
 			System.exit(0);
 		}
@@ -35,4 +30,5 @@ public class ProxyMessageErrorHandler implements ProxyMessageHandler {
 	public String name() {
 		return ProxyDataTypeEnum.DISCONNECT.getDesc();
 	}
+
 }
@@ -0,0 +1,91 @@
+package org.dromara.neutrinoproxy.client.sdk.handler;
+
+import com.google.common.collect.Lists;
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.nio.NioEventLoopGroup;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.dromara.neutrinoproxy.client.sdk.config.IProxyConfiguration;
+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
+import org.dromara.neutrinoproxy.client.sdk.core.IAbProxyClientService;
+import org.dromara.neutrinoproxy.core.ProxyDataTypeEnum;
+import org.dromara.neutrinoproxy.core.ProxyMessage;
+import org.dromara.neutrinoproxy.core.ProxyMessageHandler;
+import org.dromara.neutrinoproxy.core.dispatcher.DefaultDispatcher;
+import org.dromara.neutrinoproxy.core.dispatcher.Dispatcher;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ *
+ * @author: gc.x
+ * @date: 2024/1/21
+ */
+public abstract class ProxyMessageFactory extends IProxyConfiguration {
+
+    public abstract void stop();
+    public abstract boolean isAotRuntime();
+    public static Map<String,BeanInfo> beanManager=new ConcurrentHashMap<>();
+    @Data
+    @Builder
+    @AllArgsConstructor
+    @NoArgsConstructor
+    public static class BeanInfo<T>{
+        private String beanName;
+        private T bean;
+        private Class<?> beanClass;
+    }
+
+    public void start(ProxyConfig proxyConfig){
+        init(proxyConfig);
+        IAbProxyClientService  clientService=new IAbProxyClientService();
+        clientService.setProxyConfig(proxyConfig);
+        clientService.setCmdTunnelBootstrap((Bootstrap)beanManager.get("cmdTunnelBootstrap").getBean());
+        clientService.setUdpServerBootstrap((Bootstrap)beanManager.get("udpServerBootstrap").getBean());
+        clientService.setIsAotRuntime(isAotRuntime());
+        clientService.init();
+    }
+
+    public void init(ProxyConfig proxyConfig){
+        beanManager.put("proxyConfig",BeanInfo.builder().bean(proxyConfig).beanName("proxyConfig").beanClass(ProxyConfig.class).build());
+        NioEventLoopGroup tunnelWorkGroup = super.tunnelWorkGroup(proxyConfig);
+        beanManager.put("tunnelWorkGroup",BeanInfo.builder().bean(tunnelWorkGroup).beanName("tunnelWorkGroup").beanClass(NioEventLoopGroup.class).build());
+        NioEventLoopGroup tcpRealServerWorkGroup = super.tcpRealServerWorkGroup(proxyConfig);
+        beanManager.put("tcpRealServerWorkGroup",BeanInfo.builder().bean(tcpRealServerWorkGroup).beanName("tcpRealServerWorkGroup").beanClass(NioEventLoopGroup.class).build());
+        NioEventLoopGroup udpServerGroup = super.udpServerGroup(proxyConfig);
+        beanManager.put("udpServerGroup",BeanInfo.builder().bean(udpServerGroup).beanName("udpServerGroup").beanClass(NioEventLoopGroup.class).build());
+        NioEventLoopGroup udpWorkGroup = super.udpWorkGroup(proxyConfig);
+        beanManager.put("udpWorkGroup",BeanInfo.builder().bean(udpWorkGroup).beanName("udpWorkGroup").beanClass(NioEventLoopGroup.class).build());
+        Bootstrap cmdTunnelBootstrap = super.cmdTunnelBootstrap(proxyConfig, tunnelWorkGroup);
+        beanManager.put("cmdTunnelBootstrap",BeanInfo.builder().bean(cmdTunnelBootstrap).beanName("cmdTunnelBootstrap").beanClass(Bootstrap.class).build());
+        Bootstrap tcpProxyTunnelBootstrap = super.tcpProxyTunnelBootstrap(proxyConfig, tunnelWorkGroup);
+        beanManager.put("tcpProxyTunnelBootstrap",BeanInfo.builder().bean(tcpProxyTunnelBootstrap).beanName("tcpProxyTunnelBootstrap").beanClass(Bootstrap.class).build());
+        Bootstrap udpProxyTunnelBootstrap = super.udpProxyTunnelBootstrap(proxyConfig, tunnelWorkGroup);
+        beanManager.put("udpProxyTunnelBootstrap",BeanInfo.builder().bean(udpProxyTunnelBootstrap).beanName("udpProxyTunnelBootstrap").beanClass(Bootstrap.class).build());
+        Bootstrap realServerBootstrap = super.realServerBootstrap(proxyConfig, tcpRealServerWorkGroup);
+        beanManager.put("realServerBootstrap",BeanInfo.builder().bean(realServerBootstrap).beanName("realServerBootstrap").beanClass(Bootstrap.class).build());
+        Bootstrap udpServerBootstrap = super.udpServerBootstrap(proxyConfig, udpServerGroup, udpWorkGroup);
+        beanManager.put("udpServerBootstrap",BeanInfo.builder().bean(udpServerBootstrap).beanName("udpServerBootstrap").beanClass(Bootstrap.class).build());
+        dispatcher(proxyConfig, tcpProxyTunnelBootstrap, realServerBootstrap);
+    }
+    public  void dispatcher(ProxyConfig proxyConfig, Bootstrap tcpProxyTunnelBootstrap, Bootstrap realServerBootstrap) {
+        List<ProxyMessageHandler> list = Lists.newArrayList(
+            new ProxyMessageAuthHandler(proxyConfig, this::stop),
+            new ProxyMessageConnectHandler(tcpProxyTunnelBootstrap,realServerBootstrap,proxyConfig),
+            new ProxyMessageDisconnectHandler(),
+            new ProxyMessageErrorHandler(),
+            new ProxyMessageTransferHandler(),
+            new UdpProxyMessageConnectHandler(proxyConfig,tcpProxyTunnelBootstrap),
+            new UdpProxyMessageTransferHandler()
+        );
+        Dispatcher<ChannelHandlerContext, ProxyMessage> dispatcher = new DefaultDispatcher<>("MessageDispatcher", list,
+            proxyMessage -> ProxyDataTypeEnum.of((int)proxyMessage.getType()) == null ?
+                null : ProxyDataTypeEnum.of((int)proxyMessage.getType()).getName());
+        beanManager.put("dispatcher",BeanInfo.builder().bean(dispatcher).beanName("dispatcher").beanClass(Dispatcher.class).build());
+    }
+}
@@ -1,14 +1,14 @@
-package org.dromara.neutrinoproxy.client.handler;
+package org.dromara.neutrinoproxy.client.sdk.handler;

+import io.netty.buffer.ByteBuf;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import lombok.extern.slf4j.Slf4j;
 import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.ProxyDataTypeEnum;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
 import org.dromara.neutrinoproxy.core.ProxyMessageHandler;
 import org.dromara.neutrinoproxy.core.dispatcher.Match;
-import io.netty.buffer.ByteBuf;
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelHandlerContext;
-import org.noear.solon.annotation.Component;

 /**
 * 传输信息处理器
@@ -16,7 +16,7 @@ import org.noear.solon.annotation.Component;
 * @date: 2022/6/16
 */
@Match(type = Constants.ProxyDataTypeName.TRANSFER)
-@Component
+@Slf4j
 public class ProxyMessageTransferHandler implements ProxyMessageHandler {

 	@Override
@@ -1,20 +1,18 @@
-package org.dromara.neutrinoproxy.client.handler;
+package org.dromara.neutrinoproxy.client.sdk.handler;

+import cn.hutool.json.JSONUtil;
 import io.netty.bootstrap.Bootstrap;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import lombok.extern.slf4j.Slf4j;
-import org.dromara.neutrinoproxy.client.config.ProxyConfig;
-import org.dromara.neutrinoproxy.client.core.ProxyChannelBorrowListener;
-import org.dromara.neutrinoproxy.client.util.ProxyUtil;
+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
+import org.dromara.neutrinoproxy.client.sdk.core.ProxyChannelBorrowListener;
+import org.dromara.neutrinoproxy.client.sdk.util.ProxyUtil;
 import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.ProxyDataTypeEnum;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
 import org.dromara.neutrinoproxy.core.ProxyMessageHandler;
 import org.dromara.neutrinoproxy.core.dispatcher.Match;
-import org.noear.snack.ONode;
-import org.noear.solon.annotation.Component;
-import org.noear.solon.annotation.Inject;

 /**
 * @author: aoshiguchen
@@ -22,17 +20,21 @@ import org.noear.solon.annotation.Inject;
 */
@Slf4j
@Match(type = Constants.ProxyDataTypeName.UDP_CONNECT)
-@Component
 public class UdpProxyMessageConnectHandler implements ProxyMessageHandler {
-    @Inject
-    private ProxyConfig proxyConfig;
-    @Inject("udpProxyTunnelBootstrap")
-    private Bootstrap udpProxyTunnelBootstrap;
+
+    private final ProxyConfig proxyConfig;
+    private final Bootstrap udpProxyTunnelBootstrap;
+
+    public UdpProxyMessageConnectHandler(ProxyConfig proxyConfig,Bootstrap udpProxyTunnelBootstrap){
+        this.proxyConfig=proxyConfig;
+        this.udpProxyTunnelBootstrap=udpProxyTunnelBootstrap;
+    }

    @Override
    public void handle(ChannelHandlerContext ctx, ProxyMessage proxyMessage) {
        final Channel cmdChannel = ctx.channel();
-        final ProxyMessage.UdpBaseInfo udpBaseInfo = ONode.deserialize(proxyMessage.getInfo(), ProxyMessage.UdpBaseInfo.class);
+        String info = proxyMessage.getInfo();
+        final ProxyMessage.UdpBaseInfo udpBaseInfo = JSONUtil.toBean(info,ProxyMessage.UdpBaseInfo.class);
        log.info("[UDP connect]info:{}", proxyMessage.getInfo());

        // 获取连接
@@ -61,4 +63,5 @@ public class UdpProxyMessageConnectHandler implements ProxyMessageHandler {
    public String name() {
        return ProxyDataTypeEnum.UDP_CONNECT.getDesc();
    }
+
 }
@@ -1,19 +1,18 @@
-package org.dromara.neutrinoproxy.client.handler;
+package org.dromara.neutrinoproxy.client.sdk.handler;

+import cn.hutool.json.JSONUtil;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.socket.DatagramPacket;
 import lombok.extern.slf4j.Slf4j;
-import org.dromara.neutrinoproxy.client.util.UdpServerUtil;
+import org.dromara.neutrinoproxy.client.sdk.util.UdpServerUtil;
 import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.ProxyDataTypeEnum;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
 import org.dromara.neutrinoproxy.core.ProxyMessageHandler;
 import org.dromara.neutrinoproxy.core.dispatcher.Match;
-import org.noear.snack.ONode;
-import org.noear.solon.annotation.Component;

 import java.net.InetSocketAddress;

@@ -23,12 +22,11 @@ import java.net.InetSocketAddress;
 */
@Slf4j
@Match(type = Constants.ProxyDataTypeName.UDP_TRANSFER)
-@Component
 public class UdpProxyMessageTransferHandler implements ProxyMessageHandler {

    @Override
    public void handle(ChannelHandlerContext ctx, ProxyMessage proxyMessage) {
-        final ProxyMessage.UdpBaseInfo udpBaseInfo = ONode.deserialize(proxyMessage.getInfo(), ProxyMessage.UdpBaseInfo.class);
+        final ProxyMessage.UdpBaseInfo udpBaseInfo = JSONUtil.toBean(proxyMessage.getInfo(),ProxyMessage.UdpBaseInfo.class);
        log.debug("[UDP transfer]info:{} data:{}", proxyMessage.getInfo(), new String(proxyMessage.getData()));
        Channel channel = UdpServerUtil.takeChannel(udpBaseInfo, ctx.channel());
        if (null == channel) {
@@ -45,4 +43,5 @@ public class UdpProxyMessageTransferHandler implements ProxyMessageHandler {
    public String name() {
        return ProxyDataTypeEnum.UDP_TRANSFER.getDesc();
    }
+
 }
@@ -1,4 +1,4 @@
-package org.dromara.neutrinoproxy.client.util;
+package org.dromara.neutrinoproxy.client.sdk.util;

 import io.netty.channel.Channel;
 import lombok.Data;
@@ -19,23 +19,22 @@
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
-package org.dromara.neutrinoproxy.client.util;
+package org.dromara.neutrinoproxy.client.sdk.util;

-import io.netty.channel.ChannelHandler;
-import io.netty.handler.ssl.SslHandler;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
-import org.dromara.neutrinoproxy.client.config.ProxyConfig;
-import org.dromara.neutrinoproxy.client.core.ProxyChannelBorrowListener;
-import org.dromara.neutrinoproxy.core.Constants;
 import io.netty.bootstrap.Bootstrap;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelOption;
+import io.netty.handler.ssl.SslHandler;
 import io.netty.util.AttributeKey;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
+import org.dromara.neutrinoproxy.client.sdk.core.ProxyChannelBorrowListener;
+import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.util.FileUtil;
-import org.noear.solon.Solon;

 import javax.net.ssl.SSLContext;
 import javax.net.ssl.SSLEngine;
@@ -180,11 +179,10 @@ public class ProxyUtil {
 		realServerChannels.clear();
 	}

-	public static String getClientId() {
+	public static String getClientId(ProxyConfig proxyConfig) {
 		if (StringUtils.isNotBlank(clientId)) {
 			return clientId;
 		}
-		ProxyConfig proxyConfig = Solon.context().getBean(ProxyConfig.class);
 		if (StringUtils.isNotBlank(proxyConfig.getTunnel().getClientId())) {
 			clientId = proxyConfig.getTunnel().getClientId();
 			return clientId;
@@ -1,4 +1,4 @@
-package org.dromara.neutrinoproxy.client.util;
+package org.dromara.neutrinoproxy.client.sdk.util;

 import io.netty.channel.Channel;
 import lombok.Data;
@@ -1,4 +1,4 @@
-package org.dromara.neutrinoproxy.client.util;
+package org.dromara.neutrinoproxy.client.sdk.util;

 import io.netty.bootstrap.Bootstrap;
 import io.netty.buffer.Unpooled;
@@ -7,11 +7,11 @@ import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelFutureListener;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
-import org.dromara.neutrinoproxy.client.config.ProxyConfig;
-import org.dromara.neutrinoproxy.client.constant.Constants;
-import org.dromara.neutrinoproxy.client.core.CustomThreadFactory;
+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
+import org.dromara.neutrinoproxy.client.sdk.constant.Constants;
+import org.dromara.neutrinoproxy.client.sdk.core.CustomThreadFactory;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
-import org.noear.solon.core.runtime.NativeDetector;
+import java.util.concurrent.TimeUnit;

 import java.util.*;
 import java.util.concurrent.*;
@@ -46,9 +46,9 @@ public class UdpServerUtil {
     * 2、维护一个UDP服务池，用于需要响应的UDP转发
     * @param proxyConfig
     */
-    public static void initCache(ProxyConfig proxyConfig, Bootstrap udpServerBootstrap) {
+    public static void initCache(ProxyConfig proxyConfig, Bootstrap udpServerBootstrap,Boolean isAotRuntime) {
        // aot 阶段，不初始化UDP服务
-        if (NativeDetector.isAotRuntime()) {
+        if (isAotRuntime) {
            return;
        }
        if (null == proxyConfig.getClient().getUdp() || StringUtils.isEmpty(proxyConfig.getClient().getUdp().getPuppetPortRange())) {
@@ -16,13 +16,18 @@
    <dependencies>
        <dependency>
            <groupId>org.dromara.neutrino-proxy</groupId>
-            <artifactId>neutrino-proxy-core</artifactId>
+            <artifactId>neutrino-proxy-client-sdk</artifactId>
            <version>${revision}</version>
        </dependency>
        <dependency>
            <groupId>org.noear</groupId>
            <artifactId>solon-lib</artifactId>
        </dependency>
+        <dependency>
+            <groupId>org.noear</groupId>
+            <artifactId>solon.aot</artifactId>
+        </dependency>
+
    </dependencies>

    <build>
@@ -1,5 +1,6 @@
 package org.dromara.neutrinoproxy.client.config;

+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
 import org.noear.solon.annotation.Component;
 import org.noear.solon.aot.RuntimeNativeMetadata;
 import org.noear.solon.aot.RuntimeNativeRegistrar;
@@ -16,11 +17,23 @@ public class NeutrinoClientRuntimeNativeRegistrar implements RuntimeNativeRegist
    public void register(AppContext context, RuntimeNativeMetadata metadata) {
        metadata.registerResourceInclude("test.jks");

+        // sdk - ProxyConfig
+        metadata.registerReflection(ProxyConfig.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
        metadata.registerReflection(ProxyConfig.Protocol.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
        metadata.registerReflection(ProxyConfig.Client.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
        metadata.registerReflection(ProxyConfig.Tunnel.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
        metadata.registerReflection(ProxyConfig.Tcp.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
        metadata.registerReflection(ProxyConfig.Udp.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
        metadata.registerReflection(ProxyConfig.Reconnection.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
+
+        // client - SolonProxyConfig
+        metadata.registerReflection(SolonProxyConfig.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
+        metadata.registerReflection(SolonProxyConfig.Protocol.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
+        metadata.registerReflection(SolonProxyConfig.Client.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
+        metadata.registerReflection(SolonProxyConfig.Tunnel.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
+        metadata.registerReflection(SolonProxyConfig.Tcp.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
+        metadata.registerReflection(SolonProxyConfig.Udp.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
+        metadata.registerReflection(SolonProxyConfig.Reconnection.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
+
    }
 }
@@ -1,30 +1,11 @@
 package org.dromara.neutrinoproxy.client.config;

-import io.netty.channel.ChannelInitializer;
-import io.netty.channel.ChannelOption;
-import io.netty.channel.ChannelPipeline;
-import io.netty.channel.nio.NioEventLoopGroup;
-import io.netty.channel.socket.SocketChannel;
-import io.netty.channel.socket.nio.NioDatagramChannel;
-import io.netty.channel.socket.nio.NioSocketChannel;
-import io.netty.handler.logging.LoggingHandler;
-import io.netty.handler.timeout.IdleStateHandler;
-import org.dromara.neutrinoproxy.client.core.*;
-import org.dromara.neutrinoproxy.client.util.ProxyUtil;
-import org.dromara.neutrinoproxy.core.*;
+import org.dromara.neutrinoproxy.client.sdk.handler.ProxyMessageFactory;
 import org.dromara.neutrinoproxy.core.aot.NeutrinoCoreRuntimeNativeRegistrar;
-import org.dromara.neutrinoproxy.core.dispatcher.DefaultDispatcher;
-import org.dromara.neutrinoproxy.core.dispatcher.Dispatcher;
-import io.netty.bootstrap.Bootstrap;
-import io.netty.channel.ChannelHandlerContext;
 import org.noear.solon.Solon;
 import org.noear.solon.annotation.Bean;
 import org.noear.solon.annotation.Configuration;
-import org.noear.solon.annotation.Inject;
-import org.noear.solon.core.bean.LifecycleBean;
-
-import java.net.InetSocketAddress;
-import java.util.List;
+import org.noear.solon.core.runtime.NativeDetector;

 /**
 * 代理配置
@@ -32,182 +13,20 @@ import java.util.List;
 * @date: 2022/10/8
 */
@Configuration
-public class ProxyConfiguration implements LifecycleBean {
+public class ProxyConfiguration extends ProxyMessageFactory {

    @Override
-    public void start() throws Throwable {
-        List<ProxyMessageHandler> list = Solon.context().getBeansOfType(ProxyMessageHandler.class);
-        Dispatcher<ChannelHandlerContext, ProxyMessage> dispatcher = new DefaultDispatcher<>("MessageDispatcher", list,
-                proxyMessage -> ProxyDataTypeEnum.of((int)proxyMessage.getType()) == null ?
-                        null : ProxyDataTypeEnum.of((int)proxyMessage.getType()).getName());
-        Solon.context().wrapAndPut(Dispatcher.class, dispatcher);
+    public void stop() {
+        Solon.stop();
    }

-    @Bean("tunnelWorkGroup")
-    public NioEventLoopGroup tunnelWorkGroup(@Inject ProxyConfig proxyConfig) {
-        return new NioEventLoopGroup(proxyConfig.getTunnel().getThreadCount());
-    }
-
-    @Bean("tcpRealServerWorkGroup")
-    public NioEventLoopGroup tcpRealServerWorkGroup(@Inject ProxyConfig proxyConfig) {
-        // 暂时先公用此配置
-        return new NioEventLoopGroup(proxyConfig.getTunnel().getThreadCount());
-    }
-
-    @Bean("udpServerGroup")
-    public NioEventLoopGroup udpServerGroup(@Inject ProxyConfig proxyConfig) {
-        // 暂时先公用此配置
-        return new NioEventLoopGroup(proxyConfig.getClient().getUdp().getBossThreadCount());
-    }
-
-    @Bean("udpWorkGroup")
-    public NioEventLoopGroup udpWorkGroup(@Inject ProxyConfig proxyConfig) {
-        // 暂时先公用此配置
-        return new NioEventLoopGroup(proxyConfig.getClient().getUdp().getWorkThreadCount());
-    }
-
-    @Bean("cmdTunnelBootstrap")
-    public Bootstrap cmdTunnelBootstrap(@Inject ProxyConfig proxyConfig,
-                                        @Inject("tunnelWorkGroup") NioEventLoopGroup tunnelWorkGroup) {
-        Bootstrap bootstrap = new Bootstrap();
-        bootstrap.group(tunnelWorkGroup);
-        bootstrap.channel(NioSocketChannel.class);
-//		bootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000);
-//		bootstrap.option(ChannelOption.SO_KEEPALIVE, true);
-//		/**
-//		 * TCP/IP协议中，无论发送多少数据，总是要在数据前面加上协议头，同时，对方接收到数据，也需要发送ACK表示确认。为了尽可能的利用网络带宽，TCP总是希望尽可能的发送足够大的数据。（一个连接会设置MSS参数，因此，TCP/IP希望每次都能够以MSS尺寸的数据块来发送数据）。
-//		 * Nagle算法就是为了尽可能发送大块数据，避免网络中充斥着许多小数据块。
-//		 */
-//		bootstrap.option(ChannelOption.TCP_NODELAY, true);
-        bootstrap.remoteAddress(InetSocketAddress.createUnresolved(proxyConfig.getTunnel().getServerIp(), proxyConfig.getTunnel().getServerPort()));
-
-        bootstrap.handler(new ChannelInitializer<SocketChannel>() {
-
-            @Override
-            public void initChannel(SocketChannel ch) throws Exception {
-                if (proxyConfig.getTunnel().getSslEnable()) {
-                    ch.pipeline().addLast(ProxyUtil.createSslHandler(proxyConfig));
-                }
-                if (null != proxyConfig.getTunnel().getTransferLogEnable() && proxyConfig.getTunnel().getTransferLogEnable()) {
-                    ch.pipeline().addFirst(new LoggingHandler(CmdChannelHandler.class));
-                }
-                ch.pipeline().addLast(new ProxyMessageDecoder(proxyConfig.getProtocol().getMaxFrameLength(),
-                        proxyConfig.getProtocol().getLengthFieldOffset(), proxyConfig.getProtocol().getLengthFieldLength(),
-                        proxyConfig.getProtocol().getLengthAdjustment(), proxyConfig.getProtocol().getInitialBytesToStrip()));
-                ch.pipeline().addLast(new ProxyMessageEncoder());
-                ch.pipeline().addLast(new IdleStateHandler(proxyConfig.getProtocol().getReadIdleTime(), proxyConfig.getProtocol().getWriteIdleTime(), proxyConfig.getProtocol().getAllIdleTimeSeconds()));
-                ch.pipeline().addLast(new CmdChannelHandler());
-            }
-        });
-        return bootstrap;
-    }
-
-    @Bean("tcpProxyTunnelBootstrap")
-    public Bootstrap tcpProxyTunnelBootstrap(@Inject ProxyConfig proxyConfig,
-                                             @Inject("tunnelWorkGroup") NioEventLoopGroup tunnelWorkGroup) {
-        Bootstrap bootstrap = new Bootstrap();
-        bootstrap.group(tunnelWorkGroup);
-        bootstrap.channel(NioSocketChannel.class);
-        bootstrap.remoteAddress(InetSocketAddress.createUnresolved(proxyConfig.getTunnel().getServerIp(), proxyConfig.getTunnel().getServerPort()));
-        bootstrap.handler(new ChannelInitializer<SocketChannel>() {
-
-            @Override
-            public void initChannel(SocketChannel ch) throws Exception {
-                if (proxyConfig.getTunnel().getSslEnable()) {
-                    ch.pipeline().addLast(ProxyUtil.createSslHandler(proxyConfig));
-                }
-                if (null != proxyConfig.getTunnel().getTransferLogEnable() && proxyConfig.getTunnel().getTransferLogEnable()) {
-                    ch.pipeline().addFirst(new LoggingHandler(TcpProxyChannelHandler.class));
-                }
-                ch.pipeline().addLast(new ProxyMessageDecoder(proxyConfig.getProtocol().getMaxFrameLength(),
-                        proxyConfig.getProtocol().getLengthFieldOffset(), proxyConfig.getProtocol().getLengthFieldLength(),
-                        proxyConfig.getProtocol().getLengthAdjustment(), proxyConfig.getProtocol().getInitialBytesToStrip()));
-                ch.pipeline().addLast(new ProxyMessageEncoder());
-                ch.pipeline().addLast(new IdleStateHandler(proxyConfig.getProtocol().getReadIdleTime(), proxyConfig.getProtocol().getWriteIdleTime(), proxyConfig.getProtocol().getAllIdleTimeSeconds()));
-                ch.pipeline().addLast(new TcpProxyChannelHandler());
-            }
-        });
-        return bootstrap;
-    }
-
-    @Bean("udpProxyTunnelBootstrap")
-    public Bootstrap udpProxyTunnelBootstrap(@Inject ProxyConfig proxyConfig,
-                                              @Inject("tunnelWorkGroup") NioEventLoopGroup tunnelWorkGroup) {
-        Bootstrap bootstrap = new Bootstrap();
-        bootstrap.group(tunnelWorkGroup);
-        bootstrap.channel(NioSocketChannel.class);
-        bootstrap.remoteAddress(InetSocketAddress.createUnresolved(proxyConfig.getTunnel().getServerIp(), proxyConfig.getTunnel().getServerPort()));
-        bootstrap.handler(new ChannelInitializer<SocketChannel>() {
-
-            @Override
-            public void initChannel(SocketChannel ch) throws Exception {
-                if (proxyConfig.getTunnel().getSslEnable()) {
-                    ch.pipeline().addLast(ProxyUtil.createSslHandler(proxyConfig));
-                }
-                if (null != proxyConfig.getTunnel().getTransferLogEnable() && proxyConfig.getTunnel().getTransferLogEnable()) {
-                    ch.pipeline().addFirst(new LoggingHandler(TcpProxyChannelHandler.class));
-                }
-                ch.pipeline().addLast(new ProxyMessageDecoder(proxyConfig.getProtocol().getMaxFrameLength(),
-                        proxyConfig.getProtocol().getLengthFieldOffset(), proxyConfig.getProtocol().getLengthFieldLength(),
-                        proxyConfig.getProtocol().getLengthAdjustment(), proxyConfig.getProtocol().getInitialBytesToStrip()));
-                ch.pipeline().addLast(new ProxyMessageEncoder());
-                ch.pipeline().addLast(new IdleStateHandler(proxyConfig.getProtocol().getReadIdleTime(), proxyConfig.getProtocol().getWriteIdleTime(), proxyConfig.getProtocol().getAllIdleTimeSeconds()));
-                ch.pipeline().addLast(new UdpProxyChannelHandler());
-            }
-        });
-        return bootstrap;
-    }
-
-    @Bean("realServerBootstrap")
-    public Bootstrap realServerBootstrap(@Inject ProxyConfig proxyConfig,
-                                             @Inject("tcpRealServerWorkGroup") NioEventLoopGroup tcpRealServerWorkGroup
-                                             ) {
-        Bootstrap bootstrap = new Bootstrap();
-        bootstrap.group(tcpRealServerWorkGroup);
-        bootstrap.channel(NioSocketChannel.class);
-        bootstrap.handler(new ChannelInitializer<SocketChannel>() {
-
-            @Override
-            public void initChannel(SocketChannel ch) throws Exception {
-                if (null != proxyConfig.getTunnel().getTransferLogEnable() && proxyConfig.getTunnel().getTransferLogEnable()) {
-                    ch.pipeline().addFirst(new LoggingHandler(RealServerChannelHandler.class));
-                }
-                ch.pipeline().addLast(new RealServerChannelHandler());
-            }
-        });
-        return bootstrap;
-    }
-
-    @Bean("udpServerBootstrap")
-    public Bootstrap udpServerBootstrap(@Inject ProxyConfig proxyConfig,
-                                        @Inject("udpServerGroup") NioEventLoopGroup udpServerGroup,
-                                        @Inject("udpWorkGroup") NioEventLoopGroup udpWorkGroup) {
-        Bootstrap bootstrap = new Bootstrap();
-        bootstrap.group(udpServerGroup)
-                // 主线程处理
-                .channel(NioDatagramChannel.class)
-                // 广播
-                .option(ChannelOption.SO_BROADCAST, true)
-                // 设置读缓冲区为2M
-                .option(ChannelOption.SO_RCVBUF, 2048 * 1024)
-                // 设置写缓冲区为1M
-                .option(ChannelOption.SO_SNDBUF, 1024 * 1024)
-                .handler(new ChannelInitializer<NioDatagramChannel>() {
-                    @Override
-                    protected void initChannel(NioDatagramChannel ch) {
-                        ChannelPipeline pipeline = ch.pipeline();
-                        if (null != proxyConfig.getClient().getUdp().getTransferLogEnable() && proxyConfig.getClient().getUdp().getTransferLogEnable()) {
-                            ch.pipeline().addFirst(new LoggingHandler(UdpRealServerHandler.class));
-                        }
-                        pipeline.addLast(udpWorkGroup, new UdpRealServerHandler());
-                    }
-                });
-        return bootstrap;
+    @Override
+    public boolean isAotRuntime() {
+        return NativeDetector.isAotRuntime();
    }

    @Bean
-    public NeutrinoCoreRuntimeNativeRegistrar neutrinoCoreRuntimeNativeRegistrar() {
+    public NeutrinoCoreRuntimeNativeRegistrar neutrinoCoreRuntimeNativeRegistrar(){
        return new NeutrinoCoreRuntimeNativeRegistrar();
    }
-
 }
@@ -0,0 +1,74 @@
+package org.dromara.neutrinoproxy.client.config;
+
+import lombok.Data;
+import org.noear.solon.annotation.Component;
+import org.noear.solon.annotation.Inject;
+
+/**
+ *
+ * @author: aoshiguchen
+ * @date: 2022/6/16
+ */
+@Data
+@Component
+public class SolonProxyConfig {
+	@Inject("${neutrino.proxy.protocol}")
+	private Protocol protocol;
+	@Inject("${neutrino.proxy.tunnel}")
+	private Tunnel tunnel;
+	@Inject("${neutrino.proxy.client}")
+	private Client client;
+
+	@Data
+	public static class Protocol {
+		private Integer maxFrameLength;
+		private Integer lengthFieldOffset;
+		private Integer lengthFieldLength;
+		private Integer initialBytesToStrip;
+		private Integer lengthAdjustment;
+		private Integer readIdleTime;
+		private Integer writeIdleTime;
+		private Integer allIdleTimeSeconds;
+	}
+
+	@Data
+	public static class Tunnel {
+		private String keyStorePassword;
+		private String jksPath;
+		private String serverIp;
+		private Integer serverPort;
+		private Boolean sslEnable;
+		private Integer obtainLicenseInterval;
+		private String licenseKey;
+		private Integer threadCount;
+		private String clientId;
+		private Boolean transferLogEnable;
+		private Boolean heartbeatLogEnable;
+		private Reconnection reconnection;
+	}
+
+	@Data
+	public static class Client {
+//		private Tcp tcp;
+		private Udp udp;
+	}
+
+	@Data
+	public static class Reconnection {
+		private Integer intervalSeconds;
+		private Boolean unlimited;
+	}
+
+	@Data
+	public static class Tcp {
+
+	}
+
+	@Data
+	public static class Udp {
+		private Integer bossThreadCount;
+		private Integer workThreadCount;
+		private String puppetPortRange;
+		private Boolean transferLogEnable;
+	}
+}
@@ -1,22 +1,14 @@
 package org.dromara.neutrinoproxy.client.core;

-import cn.hutool.core.util.StrUtil;
-import org.dromara.neutrinoproxy.client.config.ProxyConfig;
-import org.dromara.neutrinoproxy.client.util.ProxyUtil;
-import org.dromara.neutrinoproxy.client.util.UdpServerUtil;
-import org.dromara.neutrinoproxy.core.ProxyMessage;
-import io.netty.bootstrap.Bootstrap;
-import io.netty.channel.*;
+import cn.hutool.core.bean.BeanUtil;
 import lombok.extern.slf4j.Slf4j;
-import org.noear.solon.Solon;
+import org.dromara.neutrinoproxy.client.config.ProxyConfiguration;
+import org.dromara.neutrinoproxy.client.config.SolonProxyConfig;
+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
 import org.noear.solon.annotation.Component;
 import org.noear.solon.annotation.Init;
 import org.noear.solon.annotation.Inject;

-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-
 /**
 * 代理客户端服务
 * @author: aoshiguchen
@@ -24,107 +16,16 @@ import java.util.concurrent.TimeUnit;
 */
@Slf4j
@Component
-public class ProxyClientService {
-	@Inject
-	private ProxyConfig proxyConfig;
-	@Inject("cmdTunnelBootstrap")
-	private Bootstrap cmdTunnelBootstrap;
-	@Inject("udpServerBootstrap")
-	private Bootstrap udpServerBootstrap;
-	private volatile Channel channel;
-	/**
-	 * 重连次数
-	 */
-	private volatile int reconnectCount = 0;
-	/**
-	 * 重连服务执行器
-	 */
-	private static final ScheduledExecutorService reconnectExecutor = Executors.newSingleThreadScheduledExecutor(new CustomThreadFactory("ClientReconnect"));
-
+public class ProxyClientService{
+    @Inject
+    private ProxyConfiguration proxyConfiguration;
+    @Inject
+    private SolonProxyConfig solonProxyConfig;
 	@Init
 	public void init() {
-		this.reconnectExecutor.scheduleWithFixedDelay(this::reconnect, 10, proxyConfig.getTunnel().getReconnection().getIntervalSeconds(), TimeUnit.SECONDS);
-
-		try {
-			this.start();
-			UdpServerUtil.initCache(proxyConfig, udpServerBootstrap);
-		} catch (Exception e) {
-			// 启动连不上也做一下重连，因此先catch异常
-			log.error("[CmdChannel] start error", e);
-		}
-	}
-
-	public void start() {
-		if (StrUtil.isEmpty(proxyConfig.getTunnel().getServerIp())) {
-			log.error("not found server-ip config.");
-			Solon.stop();
-			return;
-		}
-		if (null == proxyConfig.getTunnel().getServerPort()) {
-			log.error("not found server-port config.");
-			Solon.stop();
-			return;
-		}
-		if (null != proxyConfig.getTunnel().getSslEnable() && proxyConfig.getTunnel().getSslEnable()
-				&& StrUtil.isEmpty(proxyConfig.getTunnel().getJksPath())) {
-			log.error("not found jks-path config.");
-			Solon.stop();
-			return;
-		}
-		if (StrUtil.isEmpty(proxyConfig.getTunnel().getLicenseKey())) {
-			log.error("not found license-key config.");
-			Solon.stop();
-			return;
-		}
-		if (null == channel || !channel.isActive()) {
-			try {
-				connectProxyServer();
-			} catch (Exception e) {
-				log.error("client start error", e);
-			}
-		} else {
-			channel.writeAndFlush(ProxyMessage.buildAuthMessage(proxyConfig.getTunnel().getLicenseKey(), ProxyUtil.getClientId()));
-		}
-	}
-
-	/**
-	 * 连接代理服务器
-	 */
-	private void connectProxyServer() throws InterruptedException {
-		cmdTunnelBootstrap.connect()
-			.addListener(new ChannelFutureListener() {
-
-				@Override
-				public void operationComplete(ChannelFuture future) throws Exception {
-					if (future.isSuccess()) {
-						channel = future.channel();
-						// 连接成功，向服务器发送客户端认证信息（licenseKey）
-						ProxyUtil.setCmdChannel(future.channel());
-						future.channel().writeAndFlush(ProxyMessage.buildAuthMessage(proxyConfig.getTunnel().getLicenseKey(), ProxyUtil.getClientId()));
-						log.info("[CmdChannel] connect proxy server success. channelId:{}", future.channel().id().asLongText());
-
-//						reconnectServiceEnable = true;
-						reconnectCount = 0;
-					} else {
-						log.info("[CmdChannel] connect proxy server failed!");
-					}
-				}
-			}).sync();
-	}
-
-	protected synchronized void reconnect() {
-		if (null != channel) {
-			if (channel.isActive()) {
-				return;
-			}
-			channel.close();
-		}
-
-		log.info("[CmdChannel] client reconnect seq:{}", ++reconnectCount);
-		try {
-			connectProxyServer();
-		} catch (Exception e) {
-			log.error("[CmdChannel] reconnect error", e);
-		}
+        log.info("start....");
+        ProxyConfig proxyConfig = BeanUtil.toBean(solonProxyConfig, ProxyConfig.class);
+        proxyConfiguration.start(proxyConfig);
+        log.info("start success!");
 	}
 }
@@ -1,87 +0,0 @@
-package org.dromara.neutrinoproxy.client.handler;
-
-import org.dromara.neutrinoproxy.client.config.ProxyConfig;
-import org.dromara.neutrinoproxy.client.core.ProxyChannelBorrowListener;
-import org.dromara.neutrinoproxy.client.util.ProxyUtil;
-import org.dromara.neutrinoproxy.core.Constants;
-import org.dromara.neutrinoproxy.core.ProxyDataTypeEnum;
-import org.dromara.neutrinoproxy.core.ProxyMessage;
-import org.dromara.neutrinoproxy.core.ProxyMessageHandler;
-import org.dromara.neutrinoproxy.core.dispatcher.Match;
-import io.netty.bootstrap.Bootstrap;
-import io.netty.channel.*;
-import org.noear.solon.annotation.Component;
-import org.noear.solon.annotation.Inject;
-
-/**
- * 连接信息处理器
- * @author: aoshiguchen
- * @date: 2022/6/16
- */
-@Match(type = Constants.ProxyDataTypeName.CONNECT)
-@Component
-public class ProxyMessageConnectHandler implements ProxyMessageHandler {
-	@Inject("tcpProxyTunnelBootstrap")
-	private Bootstrap tcpProxyTunnelBootstrap;
-	@Inject("realServerBootstrap")
-	private Bootstrap realServerBootstrap;
-	@Inject
-	private ProxyConfig proxyConfig;
-
-	@Override
-	public void handle(ChannelHandlerContext ctx, ProxyMessage proxyMessage) {
-		final Channel cmdChannel = ctx.channel();
-		final String visitorId = proxyMessage.getInfo();
-		String[] serverInfo = new String(proxyMessage.getData()).split(":");
-		String ip = serverInfo[0];
-		int port = Integer.parseInt(serverInfo[1]);
-		// 连接真实的、被代理的服务
-		realServerBootstrap.connect(ip, port).addListener(new ChannelFutureListener() {
-
-			@Override
-			public void operationComplete(ChannelFuture future) throws Exception {
-
-				// 连接后端服务器成功
-				if (future.isSuccess()) {
-					final Channel realServerChannel = future.channel();
-
-					realServerChannel.config().setOption(ChannelOption.AUTO_READ, false);
-
-					// 获取连接
-					ProxyUtil.borrowTcpProxyChanel(tcpProxyTunnelBootstrap, new ProxyChannelBorrowListener() {
-
-						@Override
-						public void success(Channel channel) {
-							// 连接绑定
-							channel.attr(Constants.NEXT_CHANNEL).set(realServerChannel);
-							realServerChannel.attr(Constants.NEXT_CHANNEL).set(channel);
-
-							// 远程绑定
-							channel.writeAndFlush(ProxyMessage.buildConnectMessage(visitorId + "@" + proxyConfig.getTunnel().getLicenseKey()));
-
-							realServerChannel.config().setOption(ChannelOption.AUTO_READ, true);
-							ProxyUtil.addRealServerChannel(visitorId, realServerChannel);
-							ProxyUtil.setRealServerChannelVisitorId(realServerChannel, visitorId);
-						}
-
-						@Override
-						public void error(Throwable cause) {
-							ProxyMessage proxyMessage = new ProxyMessage();
-							proxyMessage.setType(ProxyMessage.TYPE_DISCONNECT);
-							proxyMessage.setInfo(visitorId);
-							cmdChannel.writeAndFlush(proxyMessage);
-						}
-					});
-
-				} else {
-					cmdChannel.writeAndFlush(ProxyMessage.buildDisconnectMessage(visitorId));
-				}
-			}
-		});
-	}
-
-	@Override
-	public String name() {
-		return ProxyDataTypeEnum.CONNECT.getDesc();
-	}
-}
@@ -38,7 +38,7 @@ neutrino:
      key-store-password: ${STORE_PASS:123456}
      jks-path: ${JKS_PATH:classpath:/test.jks}
      # 服务端IP
-      server-ip: ${SERVER_IP:localhost}
+      server-ip: ${SERVER_IP:}
      # 服务端端口(对应服务端app.yml中的tunnel.port、tunnel.ssl-port)
      server-port: ${SERVER_PORT:9002}
      # 是否启用SSL(注意：该配置必须和server-port对应上)
@@ -7,7 +7,7 @@
    <parent>
        <groupId>org.noear</groupId>
        <artifactId>solon-parent</artifactId>
-        <version>2.5.12</version>
+        <version>2.7.0-M2</version>
        <relativePath />
    </parent>

@@ -20,6 +20,7 @@
        <module>neutrino-proxy-core</module>
        <module>neutrino-proxy-client</module>
        <module>neutrino-proxy-server</module>
+        <module>neutrino-proxy-client-sdk</module>
    </modules>

    <properties>
Author	SHA1	Message	Date
aoshiguchen	99a93bb8a8	解决后台分页查询的已知问题	2024-04-09 11:51:49 +08:00
aoshiguchen	1bbf13763f	更新workflows.	2024-03-22 23:14:18 +08:00
aoshiguchen	75cf0702f2	更新workflows	2024-03-22 22:24:20 +08:00
aoshiguchen	a367865585	Merge branch 'dev' into feature/sdk	2024-03-22 21:43:19 +08:00
aoshiguchen	2d4a70ed22	Merge branch 'dev' into feature/sdk	2024-02-19 18:20:30 +08:00
aoshiguchen	dcf834c261	更新readme	2024-02-01 21:05:33 +08:00
aoshiguchen	ccb6fe0fda	更新VLog	2024-02-01 20:35:43 +08:00
aoshiguchen	afb4d63df0	Merge remote-tracking branch 'origin/feature/sdk' into feature/sdk	2024-02-01 20:32:53 +08:00
aoshiguchen	11794e719d	升级solon版本到2.7.0-M2，解决不在当前目录下启动时找不到配置文件的问题	2024-02-01 20:30:09 +08:00
傲世孤尘	ca1ae2eb67	!60 starter添加工具类 Merge pull request !60 from xgc/feature/sdk	2024-01-26 08:57:58 +00:00
xgc	d996cf096e	修改starter打包	2024-01-26 16:49:17 +08:00
xgc	641e3533ea	starter添加工具类	2024-01-26 16:49:14 +08:00
xgc	dd1c65f2e4	starter添加工具类	2024-01-26 16:49:14 +08:00
aoshiguchen	bd7f11a9f5	..	2024-01-26 10:37:40 +08:00
傲世孤尘	0a09eb30df	!59 删除stater敏感信息 Merge pull request !59 from xgc/feature/sdk	2024-01-25 07:33:24 +00:00
xgc	a4eead50a0	starter配置方式启动跳板机	2024-01-25 10:39:40 +08:00
xgc	3f2e86be31	删除starter敏感信息	2024-01-25 10:38:26 +08:00
aoshiguchen	921467078d	去掉客户端配置敏感信息	2024-01-24 22:18:46 +08:00
aoshiguchen	750e6505ec	日志调整	2024-01-24 22:16:46 +08:00
aoshiguchen	6ad8b199a9	解决客户端打原生包启动报错	2024-01-24 22:15:52 +08:00
aoshiguchen	d7d4fbaa73	解决客户端打包报sdk项目启动类找不到的问题	2024-01-24 21:22:27 +08:00
aoshiguchen	ef1a4110ff	新增idea图标	2024-01-24 21:04:22 +08:00
aoshiguchen	9dc6f0d479	去掉jdk17中被标记为废弃的安全管理器	2024-01-24 21:03:03 +08:00
傲世孤尘	5f39869400	!58 优化代码 SDK去除solon或者spring的bean注入 Merge pull request !58 from xgc/feature/sdk	2024-01-24 04:46:24 +00:00
xgc	c89daf1e60	starter内添加了SSH中转隧道的实现	2024-01-24 12:35:13 +08:00
xgc	c5d0763172	starter内添加了SSH中转隧道的实现	2024-01-24 12:34:18 +08:00
xgc	f525c45f8c	去除client里面bean注入部分	2024-01-23 11:55:30 +08:00
xgc	e219cfe070	优化代码去除solon或者spring的bean注入	2024-01-23 11:52:38 +08:00
傲世孤尘	2b0e37ec86	!57 移动starter位置 Merge pull request !57 from xgc/feature/sdk	2024-01-22 04:21:40 +00:00
xgc	be1621c42d	移动starter位置	2024-01-22 12:16:39 +08:00
aoshiguchen	d367c3099d	新增client+目录	2024-01-22 11:44:48 +08:00
傲世孤尘	19f77bd0d0	!56 starter添加启动配置 Merge pull request !56 from xgc/feature/sdk	2024-01-22 03:31:10 +00:00
xgc	878c4284ef	代码优化	2024-01-21 20:33:35 +08:00
xgc	17b73f2f45	添加是否启动配置	2024-01-21 20:21:08 +08:00
傲世孤尘	c7dc0c71df	!55 sdk模块去除solon相关依赖 Merge pull request !55 from xgc/feature/sdk	2024-01-21 10:26:49 +00:00
xgc	47318beb87	封装client-starter模块	2024-01-21 17:54:52 +08:00
xgc	78c93cf3c3	sdk模块去除solon相关依赖	2024-01-21 15:47:21 +08:00
xgc	d52b6a86c0	sdk模块去除solon相关依赖	2024-01-21 15:42:08 +08:00
傲世孤尘	83269f93e1	!54 初步拆分sdk部分 Merge pull request !54 from xgc/feature/sdk	2024-01-21 05:39:36 +00:00
xgc	191b9e1758	基本拆分完，只剩下ProxyConfig配置文件的获取要与spring兼容问题，暂定使用ymlUtil	2024-01-21 12:39:26 +08:00
xgc	0dd71195cd	删除client多余部分	2024-01-20 22:56:47 +08:00
xgc	3596d147b8	初步拆分SDK	2024-01-20 22:37:52 +08:00