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

更新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 = Thread.currentThread().getThreadGroup();
 		group = (s != null) ? s.getThreadGroup() :
 			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.sdk.constant.Constants;
-import org.dromara.neutrinoproxy.client.util.UdpChannelBindInfo;
+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 final ProxyConfig proxyConfig;
-	private 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);
+        JSONObject load = JSONUtil.parseObj(info);
-        Integer code = load.get("code").getInt();
+        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.*;
 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.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());
+        JSONObject load = JSONUtil.parseObj(proxyMessage.getInfo());
-        Integer code = load.get("code").getInt();
+        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.sdk.config.ProxyConfig;
-import org.dromara.neutrinoproxy.client.core.ProxyChannelBorrowListener;
+import org.dromara.neutrinoproxy.client.sdk.core.ProxyChannelBorrowListener;
-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.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;
+    private final ProxyConfig proxyConfig;
-    @Inject("udpProxyTunnelBootstrap")
+    private final Bootstrap udpProxyTunnelBootstrap;
-    private 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.sdk.config.ProxyConfig;
-import org.dromara.neutrinoproxy.client.constant.Constants;
+import org.dromara.neutrinoproxy.client.sdk.constant.Constants;
-import org.dromara.neutrinoproxy.client.core.CustomThreadFactory;
+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 org.dromara.neutrinoproxy.client.sdk.handler.ProxyMessageFactory;
 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.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.runtime.NativeDetector;
 import org.noear.solon.core.bean.LifecycleBean;
 import java.net.InetSocketAddress;
 import java.util.List;
 /**
 * 代理配置
@@ -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 {
+    public void stop() {
-        List<ProxyMessageHandler> list = Solon.context().getBeansOfType(ProxyMessageHandler.class);
+        Solon.stop();
        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);
    }
-    @Bean("tunnelWorkGroup")
+    @Override
-    public NioEventLoopGroup tunnelWorkGroup(@Inject ProxyConfig proxyConfig) {
+    public boolean isAotRuntime() {
-        return new NioEventLoopGroup(proxyConfig.getTunnel().getThreadCount());
+        return NativeDetector.isAotRuntime();
    }
    @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;
    }
    @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 cn.hutool.core.bean.BeanUtil;
 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 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 {
+public class ProxyClientService{
-	@Inject
+    @Inject
-	private ProxyConfig proxyConfig;
+    private ProxyConfiguration proxyConfiguration;
-	@Inject("cmdTunnelBootstrap")
+    @Inject
-	private Bootstrap cmdTunnelBootstrap;
+    private SolonProxyConfig solonProxyConfig;
 	@Inject("udpServerBootstrap")
 	private Bootstrap udpServerBootstrap;
 	private volatile Channel channel;
 	/**
 	 * 重连次数
 	 */
 	private volatile int reconnectCount = 0;
 	/**
 	 * 重连服务执行器
 	 */
 	private static final ScheduledExecutorService reconnectExecutor = Executors.newSingleThreadScheduledExecutor(new CustomThreadFactory("ClientReconnect"));
 	@Init
 	public void init() {
-		this.reconnectExecutor.scheduleWithFixedDelay(this::reconnect, 10, proxyConfig.getTunnel().getReconnection().getIntervalSeconds(), TimeUnit.SECONDS);
+        log.info("start....");
-
+        ProxyConfig proxyConfig = BeanUtil.toBean(solonProxyConfig, ProxyConfig.class);
-		try {
+        proxyConfiguration.start(proxyConfig);
-			this.start();
+        log.info("start success!");
 			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);
 		}
 	}
 }
@@ -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