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

Merge pull request !60 from xgc/feature/sdk

.github/workflows/linux_mac_native.yml

@@ -12,7 +12,7 @@ jobs:
       fail-fast: false
       matrix:
         # see: https://docs.github.com/zh/actions/using-jobs/choosing-the-runner-for-a-job
-#        os: ['ubuntu-20.04', 'macos-12']
+        # os: ['ubuntu-20.04', 'macos-12']
         os: ['ubuntu-20.04']
     name: build - ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
@@ -30,12 +30,12 @@ jobs:
       run: |
         cd neutrino-proxy-admin
         npm install
-        npm run build:docker·
+        npm run build:docker
         cp -rf ./dist/ ./../neutrino-proxy-server/src/main/resources/static/
-    - name: GitHub Action for GraalVM JDK 17
+    - name: GitHub Action for GraalVM JDK 21
       uses: graalvm/setup-graalvm@v1
       with:
-        java-version: '21.0.1' # for a specific JDK 17; or '17' for the latest JDK 17
+        java-version: '21.0.1' # for a specific JDK 21
         distribution: 'graalvm' # New 'distribution' option
         github-token: ${{ secrets.GITHUB_TOKEN }}
     - name: Cache local Maven repository
@@ -45,34 +45,55 @@ jobs:
         key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
         restore-keys: |
           ${{ runner.os }}-maven-
+    - name: Set vars
+      shell: bash
+      run: |
+        OS=$(echo '${{ runner.os }}' | awk '{print tolower($0)}')
+        [[ $OS == 'ubuntu' ]] && echo "OS=linux" >> $GITHUB_ENV || echo "OS=$OS" >> $GITHUB_ENV
+        [[ $OS == 'macos' ]] && echo "OS=darwin" >> $GITHUB_ENV || echo "OS=$OS" >> $GITHUB_ENV
+        echo "VERSION=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout)" >> $GITHUB_ENV
     - name: Build with Maven (neutrino-proxy-server)
       run: |
         mvn clean install -pl neutrino-proxy-core -am -DskipTests --no-transfer-progress
         cd neutrino-proxy-server 
         mvn clean native:compile -P native --file pom.xml --no-transfer-progress
         chmod +x target/neutrino-proxy-server
-        cp target/neutrino-proxy-server ./../neutrino-proxy-server-${{ github.ref_name }}
-        cp target/classes/app-copy.yml ./../neutrino-proxy-server-${{ github.ref_name }}/app.yml
+        mkdir ./../neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native
+        cp target/neutrino-proxy-server ./../neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native/neutrino-proxy-server
+        cp target/classes/app-copy.yml ./../neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native/app.yml
     - name: Archive zip (neutrino-proxy-server)
       uses: thedoctor0/zip-release@master
       with:
         type: 'zip'
-        path: 'neutrino-proxy-server-${{ github.ref_name }}'
-        filename: neutrino-proxy-server-${{ matrix.os }}-${{ github.ref_name }}.zip
+        path: 'neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native'
+        filename: neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native.zip
     - name: Build with Maven (neutrino-proxy-client)
       run: |
         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
         chmod +x target/neutrino-proxy-client
-        cp target/neutrino-proxy-client ./../neutrino-proxy-client-${{ github.ref_name }}
-        cp target/classes/app-copy.yml ./../neutrino-proxy-client-${{ github.ref_name }}/app.yml
+        mkdir ./../neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native
+        cp target/neutrino-proxy-client ./../neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native/neutrino-proxy-client
+        cp target/classes/app-copy.yml ./../neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native/app.yml
     - name: Archive zip (neutrino-proxy-client)
       uses: thedoctor0/zip-release@master
       with:
         type: 'zip'
-        path: 'neutrino-proxy-client-${{ github.ref_name }}'
-        filename: neutrino-proxy-client-${{ matrix.os }}-${{ github.ref_name }}.zip
+        path: 'neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native'
+        filename: neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native.zip
+    # 上传构建产物
+    - name: Upload artifact
+      uses: actions/[email protected]
+      with:
+        name: neutrino-proxy-server-client-${{ env.OS }}-${{ env.VERSION }}
+        path: |
+          neutrino-proxy-server/target/neutrino-proxy-server.jar
+          neutrino-proxy-client/target/neutrino-proxy-client.jar
+          neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native.zip
+          neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native.zip
+        # 保存时间，默认 90 天
+        retention-days: 5
     # GitHub 上创建 release
     - name: Release
       uses: softprops/action-gh-release@v1
@@ -81,7 +102,7 @@ jobs:
         files: |
           neutrino-proxy-server/target/neutrino-proxy-server.jar
           neutrino-proxy-client/target/neutrino-proxy-client.jar
-          neutrino-proxy-server-${{ matrix.os }}-${{ github.ref_name }}.zip
-          neutrino-proxy-client-${{ matrix.os }}-${{ github.ref_name }}.zip
+          neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native.zip
+          neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native.zip
         prerelease: true
         token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/windows-native.yml

@@ -31,10 +31,10 @@ jobs:
         npm install
         npm run build:docker
         cp -r ./dist/ ./../neutrino-proxy-server/src/main/resources/static/
-    - name: GitHub Action for GraalVM JDK 17
+    - name: GitHub Action for GraalVM JDK 21
       uses: graalvm/setup-graalvm@v1
       with:
-        java-version: '21.0.1' # for a specific JDK 17; or '17' for the latest JDK 17
+        java-version: '21.0.1' # for a specific JDK 21;
         distribution: 'graalvm' # New 'distribution' option
         github-token: ${{ secrets.GITHUB_TOKEN }}
     - name: Cache local Maven repository
@@ -44,32 +44,56 @@ jobs:
         key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
         restore-keys: |
           ${{ runner.os }}-maven-
+    - name: Set vars
+      shell: bash
+      run: |
+        OS=$(echo '${{ runner.os }}' | awk '{print tolower($0)}')
+        [[ $OS == 'ubuntu' ]] && echo "OS=linux" >> $GITHUB_ENV || echo "OS=$OS" >> $GITHUB_ENV
+        [[ $OS == 'macos' ]] && echo "OS=darwin" >> $GITHUB_ENV || echo "OS=$OS" >> $GITHUB_ENV
+        echo "VERSION=$(mvn help:evaluate -Dexpression=project.version -q -DforceStdout)" >> $GITHUB_ENV
     - name: Build with Maven (neutrino-proxy-server)
       run: |
         set MAVEN_OPTS="-Duser.language=UTF-8 -Dfile.encoding=UTF-8"
         mvn clean install -pl neutrino-proxy-core -am -DskipTests --no-transfer-progress
         cd neutrino-proxy-server
         mvn clean native:compile -P native --file pom.xml --no-transfer-progress
-        cp target/neutrino-proxy-server.exe ./../neutrino-proxy-server.exe
+        mkdir ./../neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native
+        cp target/neutrino-proxy-server.exe ./../neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native/neutrino-proxy-server.exe
+        cp target/classes/app-copy.yml ./../neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native/app.yml
     - name: Archive zip (neutrino-proxy-server)
       uses: thedoctor0/zip-release@master
       with:
         type: 'zip'
-        path: 'neutrino-proxy-server.exe'
-        filename: neutrino-proxy-server-${{ matrix.os }}-${{ github.ref_name }}.zip
+        path: 'neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native'
+        filename: neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native.zip
     - 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
-        cp target/neutrino-proxy-client.exe ./../neutrino-proxy-client.exe
+        mkdir ./../neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native
+        cp target/neutrino-proxy-client.exe ./../neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native/neutrino-proxy-client.exe
+        cp target/classes/app-copy.yml ./../neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native/app.yml
     - name: Archive zip (neutrino-proxy-client)
       uses: thedoctor0/zip-release@master
       with:
         type: 'zip'
-        path: 'neutrino-proxy-client.exe'
-        filename: neutrino-proxy-client-${{ matrix.os }}-${{ github.ref_name }}.zip
+        path: 'neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native'
+        filename: neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native.zip
+    # 上传构建产物
+    - name: Upload artifact
+      uses: actions/[email protected]
+      with:
+        name: neutrino-proxy-server-client-${{ env.OS }}-${{ env.VERSION }}
+        path: |
+          neutrino-proxy-server/target/neutrino-proxy-server.jar
+          neutrino-proxy-client/target/neutrino-proxy-client.jar
+          neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native.zip
+          neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native.zip
+        # 保存时间，默认 90 天
+        retention-days: 5
     # GitHub 上创建 release
     - name: Release
       uses: softprops/action-gh-release@v1
@@ -78,7 +102,7 @@ jobs:
         files: |
           neutrino-proxy-server/target/neutrino-proxy-server.jar
           neutrino-proxy-client/target/neutrino-proxy-client.jar
-          neutrino-proxy-server-${{ matrix.os }}-${{ github.ref_name }}.zip
-          neutrino-proxy-client-${{ matrix.os }}-${{ github.ref_name }}.zip
+          neutrino-proxy-server-${{ env.OS }}-${{ env.VERSION }}-native.zip
+          neutrino-proxy-client-${{ env.OS }}-${{ env.VERSION }}-native.zip
         prerelease: true
         token: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -60,3 +60,5 @@ logs
 data
 **/cert/**
 neutrino-proxy-server/src/main/resources/static/**
+
+client+/neutrino-proxy-client-chrome-plugin

Milestone.md

@@ -14,3 +14,5 @@
 - 2023-09-07 1.8.6版本发布，后台若干细节优化
 - 2023-09-22 1.9.0版本发布，端口映射支持UDP协议
 - 2023-09-25 中微子代理Gitee Star数突破1000
+- 2023-10-31 2.0.0版本发布，升级jdk版本至jdk17、支持原生编译、去掉sqlite改为默认H2数据库
+- 2023-12-21 2.0.1版本发布，jdk版本升级到21，支持安全组(黑/白名单IP限制)、限速

README.md

@@ -88,6 +88,12 @@
 <a href="https://gitee.com/songyinyin" target="_blank">
 <img src="assets/developer/songyinyin.png" width="11%">
 </a>
+<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>
 
 #  ❤️ 感谢

VLog.md

@@ -75,4 +75,13 @@
 
 ## 2.0.1
 - jdk版本升级为21
-- native部署，后台新增提交到后端，数据库乱码问题
+- 新增安全组模块，支持黑名单、白名单限制
+- 支持对用户、license限速
+- 修复HTTP(S)映射时使用tcp端口访问正常，使用域名访问偶现一直loading的问题
+- 修复HTTP(S)映射时使用映射的域名上传文件时，连接中断的问题
+
+## 2.0.2
+- 升级solon版本到2.7.0-M2，解决不在当前目录下启动时找不到配置文件的问题
+- client抽出sdk（还需测试windows原生部署、进一步抽出neutrino-proxy-sdk）
+- 修复管理后台分页查询的已知问题
+- 修复native下，批量删除端口池报错的问题

client+/neutrino-proxy-client-starter/Dockerfile

@@ -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

client+/neutrino-proxy-client-starter/pom.xml

@@ -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>

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/SpringProxyClient.java

@@ -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);
+    }
+
+}

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/config/MainBusListeners.java

@@ -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());
+    }
+}

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/config/ProxyConfiguration.java

@@ -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;
+    }
+}

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/config/SpringProxyConfig.java

@@ -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;
+	}
+}

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/core/ProxyClientService.java

@@ -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);
+            });
+        }
+    }
+}

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/ssh/SSHConnectionFactory.java

@@ -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();
+}

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/ssh/SSHConnectionService.java

@@ -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();
+}

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/ssh/SSHConnectionServiceImpl.java

@@ -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();
+    }
+}

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/ssh/SSHProxy.java

@@ -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;
+
+}

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/ssh/SSHProxyFactory.java

@@ -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();
+}

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/ssh/SSHProxyFactoryImpl.java

@@ -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!");
+        }
+    }
+}

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/util/ApplicationContextUtils.java

@@ -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);
+    }
+}

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/util/RemoteDeployUtil.java

@@ -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);
+    }
+}
+
+
+

client+/neutrino-proxy-client-starter/src/main/java/org/dromara/neutrinoproxy/client/starter/util/SSHClient.java

@@ -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();
+            }
+        }
+    }
+}

client+/neutrino-proxy-client-starter/src/main/resources/application.yml

@@ -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:
+

docs/article/2023/03/index.MD

@@ -20,7 +20,7 @@
 > 从1.9.0之前的版本升级需要注意：
 - 在项目`neutrino-proxy-server/src/main/resources/sql`目录下找到mysql/sqlite的增量sql文件`UPDATE-20230922.SQL`,执行更新自己的中微子代理数据库
 - 参照[官网服务端配置](https://dromara.gitee.io/neutrino-proxy/pages/f2d0f1)调整现有的服务端配置
-- 参照[官网客户端配置](https://dromara.gitee.io/neutrino-proxy/pages/50ce10)吊证现有的客户端配置
+- 参照[官网客户端配置](https://dromara.gitee.io/neutrino-proxy/pages/50ce10)调整现有的客户端配置
 - 从[仓库发行版](https://gitee.com/dromara/neutrino-proxy/releases)下载最新版本的客户端(neutrino-proxy-client.jar)、服务端(neutrino-proxy-server.jar、 neutrino-proxy-admin.zip)部署文件。若为服务端是docker镜像部署，则更新镜像重启即可
 
 ## 项目简介

docs/article/2023/06/index.md

@@ -0,0 +1,62 @@
+# NeutrinoProxy2.0.1发布，新增IP访问拦截+限速支持
+
+## 项目简介
+- [中微子代理(neutrino-proxy)](https://gitee.com/asgc/neutrino-proxy) 是一款基于Solon、Netty的内网穿透神器。该项目采用最为宽松的MIT协议，因此您可以对它进行复制、修改、传播并用于任何个人或商业行为。
+- 市面上基于内网穿透的常见产品有：花生壳、TeamView、cpolar等。
+- 常见的使用场景：
+    - 本地开发调试第三方回调
+    - 本地开发异地接口连调
+    - 远程登录内网windows机器
+    - 将本地服务映射到外网，用于演示
+- Gitee仓库：https://gitee.com/dromara/neutrino-proxy
+- Github仓库：https://github.com/dromara/neutrino-proxy
+- 官网地址1: https://neutrino-proxy.dromara.org
+- 官网地址2: https://dromara.gitee.io/neutrino-proxy
+
+## 主要特点：
+- 1、流量监控：首页图表、报表管理多维度流量监控。全方位掌握实时、历史代理数据。
+- 2、用户/License：支持多用户、多客户端使用。后台禁用实时生效。
+- 3、端口池：对外端口统一管理，支持用户、License独占端口。
+- 4、端口映射：新增、编辑、删除、禁用实时生效。
+- 5、Docker：服务端/客户端支持Docker一键部署。
+- 6、SSL证书：隧道通信支持SSL加密，保护您的数据安全。
+- 7、域名映射：支持绑定子域名，方便本地调试三方回调
+- 8、多种协议：支持代理TCP、HTTP、HTTPS、UDP协议
+- 9、原生部署：支持编译为原生可执行文件，更低部署门槛、更少内存占用
+- 10、安全组：支持黑/白名单IP访问限制
+- 11、限速：支持对License、端口映射限制上传/下载速度
+- 12、采用最为宽松的MIT协议，免去你的后顾之忧
+
+## 本次更新内容
+- jdk版本升级为21
+- 新增安全组模块，支持黑名单、白名单限制
+- 支持对用户、license限速
+- 修复HTTP(S)映射时使用tcp端口访问正常，使用域名访问偶现一直loading的问题
+- 修复HTTP(S)映射时使用映射的域名上传文件时，连接中断的问题
+
+## 安装使用说明
+- 快速上手：https://neutrino-proxy.dromara.org/neutrino-proxy/pages/793dcb/
+- 升级须知： 
+  - jdk版本升级为了jdk21，jar部署时请注意
+  - 涉及到表结构变更，执行增量SQL：https://gitee.com/dromara/neutrino-proxy/blob/master/neutrino-proxy-server/src/main/resources/sql/mysql/update/UPDATE-20231215.SQL
+
+## 运行示例
+#### License限速
+<img src="./license2.png" width="100%"/>
+
+#### 端口映射限速
+<img src="./port-mapping2.png" width="100%"/>
+
+#### 安全组
+<img src="./security-group1.png" width="100%"/>
+<img src="./security-rule1.png" width="100%"/>
+
+## 联系我们
+笔者时间、能力有限，且开源项目非一朝一夕之事，存在众多问题亦在所难免。使用、学习过程中有任何问题欢迎大家与我联系。
+
+对项目有什么想法或者建议，可以加我微信拉交流群，或者创建[issues](https://gitee.com/dromara/neutrino-proxy/issues)，一起完善项目
+
+- 微信号：yuyunshize
+- Email: aoshiguchen@dromara.org
+- 微信二维码（添加时请备注"中微子进群"）：
+  <img src="MyWeChatQRCode.jpeg" width="100%"/>

neutrino-proxy-admin/src/api/securityGroup.js

@@ -1,68 +1,82 @@
 import request from '@/utils/request'
 
-const baseUri = '/security';
+export function fetchGroupPage(query) {
+  return request({
+    url: '/security/group/page',
+    method: 'get',
+    params: query
+  })
+}
 
 export function fetchGroupList() {
   return request({
-    url: `${baseUri}/group/s`,
+    url: '/security/group/list',
     method: 'get'
   })
 }
 
-export function fetchGroupOne(groupId) {
+export function fetchGroupDetail(query) {
   return request({
-    url: `${baseUri}/group/getOne?groupId=${groupId}`,
-    method: 'get'
+    url: '/security/group/detail',
+    method: 'get',
+    params: query
   })
 }
 
 export function createGroup(data) {
   return request({
-    url: `${baseUri}/group/create`,
+    url: `/security/group/create`,
     method: 'post',
     data
   })
 }
 
-export function updateGroup(data) {
+export function updateGroup(query) {
   return request({
-    url: `${baseUri}/group/update`,
+    url: `/security/group/update`,
+    method: 'post',
+    params: query
+  })
+}
+
+export function deleteGroup(data) {
+  return request({
+    url: '/security/group/delete',
     method: 'post',
     data
   })
 }
 
-export function deleteGroup(groupId) {
+export function updateGroupEnableStatus(id, enable) {
   return request({
-    url: `${baseUri}/group/delete?groupId=${groupId}`,
-    method: 'post'
+    url: '/security/group/update/enable-status',
+    method: 'post',
+    data: {
+      id: id,
+      enable: enable
+    }
   })
 }
 
-export function enableGroup(groupId) {
+export function fetchRulePage(query) {
   return request({
-    url: `${baseUri}/group/enable?groupId=${groupId}`,
-    method: 'post'
+    url: '/security/rule/page',
+    method: 'get',
+    params: query
   })
 }
 
-export function disableGroup(groupId) {
+export function fetchRuleList(query) {
   return request({
-    url: `${baseUri}/group/disable?groupId=${groupId}`,
-    method: 'post'
-  })
-}
-
-export function fetchRuleList(groupId) {
-  return request({
-    url: `${baseUri}/rule/s?groupId=${groupId}`,
-    method: 'get'
+    url: '/security/rule/list',
+    method: 'get',
+    params: query
   })
 }
 
 export function createRule(data) {
   return request({
-    url: `${baseUri}/rule/create`,
+    url: `/security/rule/create`,
     method: 'post',
     data
   })
@@ -70,28 +84,26 @@ export function createRule(data) {
 
 export function updateRule(data) {
   return request({
-    url: `${baseUri}/rule/update`,
+    url: `/security/rule/update`,
     method: 'post',
     data
   })
 }
-export function deleteRule(ruleId) {
+export function deleteRule(query) {
   return request({
-    url: `${baseUri}/rule/delete?ruleId=${ruleId}`,
-    method: 'post'
+    url: '/security/rule/delete',
+    method: 'post',
+    params: query
   })
 }
 
-export function enableRule(ruleId) {
+export function updateRuleEnableStatus(id, enable) {
   return request({
-    url: `${baseUri}/rule/enable?ruleId=${ruleId}`,
-    method: 'post'
+    url: '/security/rule/update/enable-status',
+    method: 'post',
+    data: {
+      id: id,
+      enable: enable
+    }
   })
 }
-
-export function disableRule(ruleId) {
-  return request({
-    url: `${baseUri}/rule/disable?ruleId=${ruleId}`,
-    method: 'post'
-  })
-}

neutrino-proxy-admin/src/components/FBATable/index.vue

@@ -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"

neutrino-proxy-admin/src/views/log/clientConnectLog.vue

@@ -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>

neutrino-proxy-admin/src/views/log/jobLog.vue

@@ -46,7 +46,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>

neutrino-proxy-admin/src/views/log/loginLog.vue

@@ -31,7 +31,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>

neutrino-proxy-admin/src/views/proxy/license.vue

@@ -36,6 +36,11 @@
           <span>{{scope.row.key}}</span>
         </template>
       </el-table-column>
+      <el-table-column align="center" :label="$t('限速')" width="100">
+        <template slot-scope="scope">
+          <span>{{scope.row.upLimitRate ? scope.row.upLimitRate : '--'}} / {{scope.row.downLimitRate ? scope.row.downLimitRate : '--'}}</span>
+        </template>
+      </el-table-column>
       <el-table-column width="150px" align="center" :label="$t('table.createTime')">
         <template slot-scope="scope">
           <span>{{scope.row.createTime | parseTime('{y}-{m}-{d} {h}:{i}')}}</span>
@@ -69,7 +74,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>
@@ -85,6 +90,12 @@
         <el-form-item :label="$t('License名称')" prop="name">
           <el-input v-model="temp.name"></el-input>
         </el-form-item>
+        <el-form-item :label="$t('上传限速')" prop="upLimitRate">
+          <el-input v-model="temp.upLimitRate" placeholder="如：10240B、500K、1M"></el-input>
+        </el-form-item>
+        <el-form-item :label="$t('下载限速')" prop="downLimitRate">
+          <el-input v-model="temp.downLimitRate" placeholder="如：10240B、500K、1M"></el-input>
+        </el-form-item>
       </el-form>
       <div slot="footer" class="dialog-footer">
         <el-button @click="dialogFormVisible = false">{{$t('table.cancel')}}</el-button>

neutrino-proxy-admin/src/views/proxy/portMapping.vue

@@ -39,17 +39,17 @@
           <span>{{ scope.row.userName }}</span>
         </template>
       </el-table-column>
-      <el-table-column align="center" :label="$t('table.licenseName')" width="130">
+      <el-table-column align="center" :label="$t('table.licenseName')" width="120">
         <template slot-scope="scope">
           <span>{{ scope.row.licenseName }}</span>
         </template>
       </el-table-column>
-      <el-table-column align="center" :label="$t('table.protocalName')" width="100">
+      <el-table-column align="center" :label="$t('table.protocalName')" width="80">
         <template slot-scope="scope">
           <span>{{ scope.row.protocal }}</span>
         </template>
       </el-table-column>
-      <el-table-column align="center" :label="$t('table.domainName')" width="200">
+      <el-table-column align="center" :label="$t('table.domainName')" width="180">
         <template slot-scope="scope">
           <span>{{ scope.row.domain }}</span>
         </template>
@@ -64,17 +64,22 @@
           <span>{{ scope.row.clientIp }}:{{ scope.row.clientPort }}</span>
         </template>
       </el-table-column>
+      <el-table-column align="center" :label="$t('限速')" width="100">
+        <template slot-scope="scope">
+          <span>{{scope.row.upLimitRate ? scope.row.upLimitRate : '--'}} / {{scope.row.downLimitRate ? scope.row.downLimitRate : '--'}}</span>
+        </template>
+      </el-table-column>
       <el-table-column align="center" :label="$t('table.desc')" width="120">
         <template slot-scope="scope">
           <span>{{ scope.row.description }}</span>
         </template>
       </el-table-column>
 
-      <el-table-column width="150px" align="center" :label="$t('table.createTime')">
-        <template slot-scope="scope">
-          <span>{{ scope.row.createTime | parseTime('{y}-{m}-{d} {h}:{i}') }}</span>
-        </template>
-      </el-table-column>
+<!--      <el-table-column width="150px" align="center" :label="$t('table.createTime')">-->
+<!--        <template slot-scope="scope">-->
+<!--          <span>{{ scope.row.createTime | parseTime('{y}-{m}-{d} {h}:{i}') }}</span>-->
+<!--        </template>-->
+<!--      </el-table-column>-->
       <el-table-column width="150px" align="center" :label="$t('table.updateTime')">
         <template slot-scope="scope">
           <span>{{ scope.row.updateTime | parseTime('{y}-{m}-{d} {h}:{i}') }}</span>
@@ -99,8 +104,7 @@
         <template slot-scope="scope">
           <el-button type="primary" size="mini" @click="handleUpdate(scope.row)">{{ $t('table.edit') }}</el-button>
           <el-button v-if="scope.row.enable == '1'" size="mini" type="danger" @click="handleModifyStatus(scope.row, 2)">{{$t('table.disable')}}</el-button>
-          <el-button v-if="scope.row.enable == '2'" size="mini" type="success"
-            @click="handleModifyStatus(scope.row, 1)">{{ $t('table.enable') }}</el-button>
+          <el-button v-if="scope.row.enable == '2'" size="mini" type="success" @click="handleModifyStatus(scope.row, 1)">{{ $t('table.enable') }}</el-button>
           <!--          <el-button size="mini" type="danger" @click="handleDelete(scope.row,'deleted')">{{$t('table.delete')}}</el-button>-->
           <ButtonPopover @handleCommitClick="handleDelete2(scope.row)" style="margin-left: 10px" />
 
@@ -110,7 +114,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>
@@ -182,6 +186,12 @@
             </el-option>
           </el-select>
         </el-form-item>
+        <el-form-item :label="$t('上传限速')" prop="upLimitRate">
+          <el-input v-model="temp.upLimitRate" placeholder="如：10240B、500K、1M"></el-input>
+        </el-form-item>
+        <el-form-item :label="$t('下载限速')" prop="downLimitRate">
+          <el-input v-model="temp.downLimitRate" placeholder="如：10240B、500K、1M"></el-input>
+        </el-form-item>
         <el-form-item :label="$t('描述')" prop="description">
           <el-input v-model="temp.description"></el-input>
         </el-form-item>

neutrino-proxy-admin/src/views/report/licenseFlowMonthReport.vue

@@ -44,7 +44,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>

neutrino-proxy-admin/src/views/report/licenseFlowReport.vue

@@ -41,7 +41,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>

neutrino-proxy-admin/src/views/report/userFlowMonthReport.vue

@@ -36,7 +36,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>

neutrino-proxy-admin/src/views/report/userFlowReport.vue

@@ -37,7 +37,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>

neutrino-proxy-admin/src/views/system/jobManager.vue

@@ -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>

neutrino-proxy-admin/src/views/system/portGroup.vue

@@ -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>

neutrino-proxy-admin/src/views/system/portPool.vue

@@ -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>

neutrino-proxy-admin/src/views/system/protocal.vue

@@ -28,7 +28,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>

neutrino-proxy-admin/src/views/system/securityGroup.vue

@@ -1,6 +1,17 @@
 <template>
   <div class="app-container calendar-list-container">
     <div class="filter-container">
+      <el-input v-model="listQuery.name" style="width:145px;margin-right:10px" placeholder="请输入名称" />
+      <el-input v-model="listQuery.description" style="width:145px;margin-right:10px" placeholder="请输入描述" />
+      <el-select v-model="listQuery.defaultPassType" placeholder="请选择默认放行类型" clearable style="width:145px;margin-right:10px">
+        <el-option v-for="item in selectObj.passType" :key="item.value" :label="item.label" :value="item.value" />
+      </el-select>
+      <el-select v-model="listQuery.enable" placeholder="请选择启用状态" clearable style="width:145px;margin-right:10px">
+        <el-option v-for="item in selectObj.statusOptions" :key="item.value" :label="item.label" :value="item.value" />
+      </el-select>
+      <el-button class="filter-item" type="primary" v-waves icon="el-icon-search" @click="handleFilter">{{
+          $t('table.search') }}
+      </el-button>
       <el-button class="filter-item" style="margin-left: 10px;" @click="handleCreate" type="primary" icon="el-icon-edit">{{$t('table.add')}}</el-button>
     </div>
 
@@ -24,24 +35,22 @@
       </el-table-column>
       <el-table-column align="center" :label="$t('table.defaultPassType')">
         <template slot-scope="scope">
-          <el-tag type="success" v-if="scope.row.defaultPassType == 'allow'">允许</el-tag>
-          <el-tag type="info" v-if="scope.row.defaultPassType == 'deny'">拒绝</el-tag>
+          <el-tag :type="scope.row.defaultPassType | passTypeFilter">{{ scope.row.defaultPassType | passTypeName }}</el-tag>
         </template>
       </el-table-column>
       <el-table-column align="center" :label="$t('table.createTime')">
         <template slot-scope="scope">
-          <span>{{scope.row.createTime}}</span>
+          <span>{{ scope.row.createTime | parseTime('{y}-{m}-{d} {h}:{i}') }}</span>
         </template>
       </el-table-column>
       <el-table-column align="center" :label="$t('table.updateTime')">
         <template slot-scope="scope">
-          <span>{{scope.row.updateTime}}</span>
+          <span>{{ scope.row.updateTime | parseTime('{y}-{m}-{d} {h}:{i}') }}</span>
         </template>
       </el-table-column>
       <el-table-column class-name="status-col" :label="$t('table.enableStatus')">
         <template slot-scope="scope">
-          <el-tag type="success" v-if="scope.row.enable == '启用'">{{scope.row.enable}}</el-tag>
-          <el-tag type="danger" v-if="scope.row.enable == '禁用'">{{scope.row.enable}}</el-tag>
+          <el-tag :type="scope.row.enable | statusFilter">{{ scope.row.enable | statusName }}</el-tag>
         </template>
       </el-table-column>
       <el-table-column align="center" :label="$t('table.actions')"  class-name="small-padding fixed-width" style="display:flex;justify-content:center">
@@ -49,8 +58,8 @@
           <div >
             <el-link :underline="false" type="primary" size="mini" @click="handleGoRulePage(scope.row)" style="font-size: 12px">{{$t('table.ruleConfig')}}</el-link>
             <el-link :underline="false" type="primary" size="mini" @click="handleUpdate(scope.row)" style="font-size: 12px">{{$t('table.edit')}}</el-link>
-            <el-link :underline="false" v-if="scope.row.enable =='启用'" size="mini" type="warning" @click="handleDisableStatus(scope.row)" style="font-size: 12px">{{$t('table.disable')}}</el-link>
-            <el-link :underline="false" v-if="scope.row.enable =='禁用'" size="mini" type="success" @click="handleEnableStatus(scope.row)" style="font-size: 12px">{{$t('table.enable')}}</el-link>
+            <el-link :underline="false" v-if="scope.row.enable =='1'" size="mini" type="warning" @click="handleModifyStatus(scope.row, 2)" style="font-size: 12px">{{$t('table.disable')}}</el-link>
+            <el-link :underline="false" v-if="scope.row.enable =='2'" size="mini" type="success" @click="handleModifyStatus(scope.row, 1)" style="font-size: 12px">{{$t('table.enable')}}</el-link>
           </div>
           <el-dropdown>
             <span class="el-dropdown-link" style="font-size: 12px">
@@ -69,6 +78,13 @@
       </el-table-column>
     </el-table>
 
+    <div class="pagination-container">
+      <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>
+
     <el-dialog :title="textMap[dialogStatus]" :visible.sync="dialogFormVisible">
       <el-form :rules="rules" ref="dataForm" :model="temp" label-position="right" label-width="120px" style='width: 500px; margin-left:10px;'>
         <el-form-item :label="$t('table.name')" prop="name">
@@ -107,34 +123,34 @@
     </el-dialog>
 
     <el-dialog :title="$t('table.securityGroupBindPortMapping')+'---'+forBindProtMappingSecurityGroup.name+'安全组'" :visible.sync="dialogBindPortMappingVisible" width="90%">
-      <el-table :key='tableKey' :data="portMappingList" v-loading="listLoading" element-loading-text="给我一点时间" border fit align="center" width="100%"
+      <el-table :key='tableKey' :data="portMappingList" v-loading="listLoading" element-loading-text="给我一点时间" border width="100%"
         highlight-current-row style="width: 100%">
         <el-table-column align="center" :label="$t('table.id')" width="50">
           <template slot-scope="scope">
             <span>{{ scope.row.id }}</span>
           </template>
         </el-table-column>
-        <el-table-column align="center" :label="$t('table.licenseName')" width="130">
+        <el-table-column align="center" :label="$t('table.licenseName')">
           <template slot-scope="scope">
             <span>{{ scope.row.licenseName }}</span>
           </template>
         </el-table-column>
-        <el-table-column align="center" :label="$t('table.protocalName')" width="100">
+        <el-table-column align="center" :label="$t('table.protocalName')" width="120">
           <template slot-scope="scope">
             <span>{{ scope.row.protocal }}</span>
           </template>
         </el-table-column>
-        <el-table-column align="center" :label="$t('table.domainName')" width="200">
+        <el-table-column align="center" :label="$t('table.domainName')">
           <template slot-scope="scope">
             <span>{{ scope.row.domain }}</span>
           </template>
         </el-table-column>
-        <el-table-column align="center" :label="$t('table.serverPort')" width="80">
+        <el-table-column align="center" :label="$t('table.serverPort')" width="100">
           <template slot-scope="scope">
             <span>{{ scope.row.serverPort }}</span>
           </template>
         </el-table-column>
-        <el-table-column align="center" :label="$t('table.proxyClient')" width="120">
+        <el-table-column align="center" :label="$t('table.proxyClient')" width="200">
           <template slot-scope="scope">
             <span>{{ scope.row.clientIp }}:{{ scope.row.clientPort }}</span>
           </template>
@@ -144,12 +160,12 @@
             <span>{{ scope.row.description }}</span>
           </template>
         </el-table-column>
-        <el-table-column class-name="status-col" :label="$t('table.enableStatus')" width="100">
+        <el-table-column class-name="status-col" :label="$t('table.enableStatus')" width="120">
           <template slot-scope="scope">
             <el-tag :type="scope.row.enable | statusFilter">{{ scope.row.enable | statusName }}</el-tag>
           </template>
         </el-table-column>
-        <el-table-column align="center" :label="$t('table.actions')" width="120" class-name="small-padding fixed-width">
+        <el-table-column align="center" :label="$t('table.actions')" width="150" class-name="small-padding fixed-width">
           <template slot-scope="scope">
             <el-button type="primary" size="mini" v-if="!scope.row.securityGroupId" @click="handleBind(scope.row)">{{$t('table.bind')}}</el-button>
             <el-button type="danger" size="mini" v-if="scope.row.securityGroupId && scope.row.securityGroupId == forBindProtMappingSecurityGroup.id" @click="handleUnbind(scope.row)">{{$t('table.unbind')}}</el-button>
@@ -160,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>
@@ -170,7 +186,7 @@
 </template>
 
 <script>
-import {fetchGroupList, createGroup, updateGroup, deleteGroup, enableGroup, disableGroup} from '@/api/securityGroup'
+import {fetchGroupPage, createGroup, updateGroup, deleteGroup, updateGroupEnableStatus} from '@/api/securityGroup'
 import { fetchList as fetchPortMappingList, portMappingBindSecurityGroup, portMappingUnbindSecurityGroup} from '@/api/portMapping'
 import waves from '@/directive/waves' // 水波纹指令
 import { parseTime } from '@/utils'
@@ -188,6 +204,15 @@ import LinkPopover from '../../components/Link/linkPopover'
       return {
         tableKey: 0,
         list: [],
+        total: null,
+        listQuery: {
+          current: 1,
+          size: 10,
+          name: undefined,
+          description: undefined,
+          defaultPassType: undefined,
+          enable: undefined
+        },
         listLoading: true,
         temp: {
           id: undefined,
@@ -195,6 +220,12 @@ import LinkPopover from '../../components/Link/linkPopover'
           description: '',
           defaultPassType: undefined
         },
+        selectObj: {
+          statusOptions: [{ label: '启用', value: 1 }, { label: '禁用', value: 2 }],
+          onlineOptions: [{ label: '在线', value: 1 }, { label: '离线', value: 2 }],
+          passType: [{ label: '允许', value: 1 }, { label: '拒绝', value: 0 }]
+
+        },
         dialogFormVisible: false,
         dialogStatus: '',
         textMap: {
@@ -231,6 +262,20 @@ import LinkPopover from '../../components/Link/linkPopover'
       }
     },
     filters: {
+      passTypeName(type) {
+        const statusMap = {
+          1: '允许',
+          0: '拒绝'
+        }
+        return statusMap[type]
+      },
+      passTypeFilter(type) {
+        const statusMap = {
+          1: 'success',
+          0: 'danger'
+        }
+        return statusMap[type]
+      },
       statusName(status) {
         const statusMap = {
           1: '启用',
@@ -257,11 +302,24 @@ import LinkPopover from '../../components/Link/linkPopover'
     methods: {
       getList() {
         this.listLoading = true
-        fetchGroupList().then(response => {
-          this.list = response.data.data
+        fetchGroupPage(this.listQuery).then(response => {
+          this.list = response.data.data.records
+          this.total = response.data.data.total
           this.listLoading = false
         })
       },
+      handleFilter() {
+        this.listQuery.current = 1
+        this.getList()
+      },
+      handleSizeChange(val) {
+        this.listQuery.size = val
+        this.getList()
+      },
+      handleCurrentChange(val) {
+        this.listQuery.current = val
+        this.getList()
+      },
       getPortMappingList() {
         this.portMappingListLoading = true
         fetchPortMappingList(this.portMappingListQuery).then(response => {
@@ -270,27 +328,16 @@ import LinkPopover from '../../components/Link/linkPopover'
           this.portMappingListQuery.current = response.data.data.current
           this.portMappingListLoading = false
         })
-    },
-      handleEnableStatus(row) {
-        enableGroup(row.id).then(response => {
-          if (response.data.code === 0) {
-            this.$message({
-              message: '操作成功',
-              type: 'success'
-            })
-            this.getList()
-          }
-        })
       },
-      handleDisableStatus(row) {
-        disableGroup(row.id).then(response => {
-          if (response.data.code === 0) {
+      handleModifyStatus(row, enable) {
+        updateGroupEnableStatus(row.id, enable).then(response => {
+          if (response.data.data.code === 0) {
             this.$message({
               message: '操作成功',
               type: 'success'
             })
-            this.getList()
           }
+          this.getList()
         })
       },
       resetTemp() {
@@ -329,8 +376,7 @@ import LinkPopover from '../../components/Link/linkPopover'
       },
       handleUpdate(row) {
         this.temp = Object.assign({}, row) // copy obj
-        this.temp.defaultPassType = row.defaultPassType == 'allow' ? 1 : 0
-        this.temp.timestamp = new Date(this.temp.timestamp)
+        // this.temp.timestamp = new Date(this.temp.timestamp)
         this.dialogStatus = 'update'
         this.dialogFormVisible = true
         this.$nextTick(() => {
@@ -357,7 +403,7 @@ import LinkPopover from '../../components/Link/linkPopover'
         })
       },
       handleDelete(row) {
-        deleteGroup(row.id).then(response => {
+        deleteGroup({groupId: row.id}).then(response => {
           if (response.data.code === 0) {
             this.$notify({
               title: '成功',
@@ -370,7 +416,9 @@ import LinkPopover from '../../components/Link/linkPopover'
         })
       },
       handleGoRulePage (row) {
-        this.$router.push(`/system/securityRule?groupId=${row.id}`)
+        this.$router.push({ path: '/system/securityRule', query: { groupId: row.id }})
+
+        // this.$router.push(`/system/securityRule?groupId=${row.id}`)
       },
       handlePortMapping(row) {
         this.dialogBindPortMappingVisible = true
@@ -413,8 +461,3 @@ import LinkPopover from '../../components/Link/linkPopover'
     }
   }
 </script>
-<style>
-  .filter-container {
-    text-align: right;
-  }
-</style>

neutrino-proxy-admin/src/views/system/securityRule.vue

@@ -6,7 +6,18 @@
       <div style="text-align: center;font-size:14px; color: #606266">{{group.description}}</div>
     </div>
 
-    <div class="filter-container" align="right">
+    <div class="filter-container">
+      <el-input v-model="listQuery.name" style="width:145px;margin-right:10px" placeholder="请输入名称" />
+      <el-input v-model="listQuery.description" style="width:145px;margin-right:10px" placeholder="请输入描述" />
+<!--      <el-select v-model="listQuery.passType" placeholder="请选择默认放行类型" clearable style="width:145px;margin-right:10px">-->
+<!--          <el-option v-for="item in selectObj.passType" :key="item.value" :label="item.label" :value="item.value" />-->
+<!--      </el-select>-->
+      <el-select v-model="listQuery.enable" placeholder="请选择启用状态" clearable style="width:145px;margin-right:10px">
+          <el-option v-for="item in selectObj.statusOptions" :key="item.value" :label="item.label" :value="item.value" />
+      </el-select>
+      <el-button class="filter-item" type="primary" v-waves icon="el-icon-search" @click="handleFilter">{{
+          $t('table.search') }}
+      </el-button>
       <el-button class="filter-item" @click="handleCreate" type="primary" icon="el-icon-edit">{{$t('table.add')}}</el-button>
     </div>
 
@@ -35,41 +46,46 @@
       </el-table-column>
       <el-table-column align="center" :label="$t('table.passType')">
         <template slot-scope="scope">
-          <el-tag type="success" v-if="scope.row.passType == 'allow'" effect="dark">允许</el-tag>
-          <el-tag type="info" v-if="scope.row.passType == 'deny'" effect="dark">拒绝</el-tag>
-        </template>
-      </el-table-column>
-      <el-table-column align="center" :label="$t('table.priority')">
-        <template slot-scope="scope">
-          <span>{{scope.row.priority}}</span>
+          <el-tag :type="scope.row.passType | passTypeFilter">{{ scope.row.passType | passTypeName }}</el-tag>
         </template>
       </el-table-column>
+<!--      <el-table-column align="center" :label="$t('table.priority')">-->
+<!--        <template slot-scope="scope">-->
+<!--          <span>{{scope.row.priority}}</span>-->
+<!--        </template>-->
+<!--      </el-table-column>-->
       <el-table-column align="center" :label="$t('table.createTime')">
         <template slot-scope="scope">
-          <span>{{scope.row.createTime}}</span>
+          <span>{{ scope.row.createTime | parseTime('{y}-{m}-{d} {h}:{i}') }}</span>
         </template>
       </el-table-column>
       <el-table-column align="center" :label="$t('table.updateTime')">
         <template slot-scope="scope">
-          <span>{{scope.row.updateTime}}</span>
+          <span>{{ scope.row.updateTime | parseTime('{y}-{m}-{d} {h}:{i}') }}</span>
         </template>
       </el-table-column>
       <el-table-column class-name="status-col" :label="$t('table.enableStatus')" width="150">
         <template slot-scope="scope">
-          <el-tag type="success" v-if="scope.row.enable == '启用'">{{scope.row.enable}}</el-tag>
-          <el-tag type="warning" v-if="scope.row.enable == '禁用'">{{scope.row.enable}}</el-tag>
+          <el-tag :type="scope.row.enable | statusFilter">{{ scope.row.enable | statusName }}</el-tag>
         </template>
       </el-table-column>
       <el-table-column align="center" :label="$t('table.actions')" width="250" class-name="small-padding fixed-width">
         <template slot-scope="scope">
           <el-link type="primary" :underline="false" size="mini" @click="handleUpdate(scope.row)" style="font-size:12px">{{$t('table.edit')}}</el-link>
-          <el-link :underline="false" v-if="scope.row.enable =='启用'" size="mini" type="warning" @click="handleDisableStatus(scope.row)" style="font-size:12px">{{$t('table.disable')}}</el-link>
-          <el-link :underline="false" v-if="scope.row.enable =='禁用'" size="mini" type="success" @click="handleEnableStatus(scope.row)" style="font-size:12px">{{$t('table.enable')}}</el-link>
+          <el-link :underline="false" v-if="scope.row.enable =='1'" size="mini" type="warning" @click="handleModifyStatus(scope.row, 2)" style="font-size:12px">{{$t('table.disable')}}</el-link>
+          <el-link :underline="false" v-if="scope.row.enable =='2'" size="mini" type="success" @click="handleModifyStatus(scope.row, 1)" style="font-size:12px">{{$t('table.enable')}}</el-link>
           <LinkPopover @handleCommitClick="handleDelete(scope.row)"/>
         </template>
       </el-table-column>
     </el-table>
 
+    <div class="pagination-container">
+      <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>
+
     <el-dialog :title="textMap[dialogStatus]" :visible.sync="dialogFormVisible" top="4vh">
       <el-form :rules="rules" ref="dataForm" :model="temp" label-position="right" label-width="100px" style='margin-left:50px;margin-right: 150px'>
         <el-form-item :label="$t('table.name')" prop="name">
@@ -93,7 +109,7 @@
             <div>每个类型中间以英文逗号分隔,形如 192.168.1.1,192.168.3.0/24 是正确的 </div>
           </div>
         </el-form-item>
-        
+
 
         <el-form-item  :label="$t('table.passType')" prop="passType">
           <el-tooltip class="item" effect="dark" :content="temp.passTypeTooltip" placement="right">
@@ -103,7 +119,7 @@
               </el-option>
             </el-select>
           </el-tooltip>
-         
+
         </el-form-item>
 
         <!-- <el-form-item :label="$t('table.priority')" prop="priority">
@@ -132,7 +148,7 @@
 </template>
 
 <script>
-import {fetchGroupOne, fetchRuleList, createRule, updateRule, deleteRule, enableRule, disableRule} from '@/api/securityGroup'
+import {fetchGroupDetail, fetchRulePage, createRule, updateRule, deleteRule, updateRuleEnableStatus} from '@/api/securityGroup'
 import waves from '@/directive/waves' // 水波纹指令
 import { parseTime } from '@/utils'
 import LinkPopover from '../../components/Link/linkPopover'
@@ -151,6 +167,16 @@ import LinkPopover from '../../components/Link/linkPopover'
         group: {},
         tableKey: 0,
         list: [],
+        total: null,
+        listQuery: {
+          current: 1,
+          size: 10,
+          groupId: undefined,
+          name: undefined,
+          description: undefined,
+          passType: undefined,
+          enable: undefined
+        },
         listLoading: true,
         temp: {
           id: undefined,
@@ -162,6 +188,12 @@ import LinkPopover from '../../components/Link/linkPopover'
           passTypeTooltip: '',
           priority: 1
         },
+        selectObj: {
+            statusOptions: [{ label: '启用', value: 1 }, { label: '禁用', value: 2 }],
+            onlineOptions: [{ label: '在线', value: 1 }, { label: '离线', value: 2 }],
+            passType: [{ label: '允许', value: 1 }, { label: '拒绝', value: 2 }]
+
+        },
         dialogFormVisible: false,
         dialogStatus: '',
         textMap: {
@@ -182,6 +214,20 @@ import LinkPopover from '../../components/Link/linkPopover'
       }
     },
     filters: {
+      passTypeName(type) {
+        const statusMap = {
+          1: '允许',
+          0: '拒绝'
+        }
+        return statusMap[type]
+      },
+      passTypeFilter(type) {
+        const statusMap = {
+          1: 'success',
+          0: 'danger'
+        }
+        return statusMap[type]
+      },
       statusName(status) {
         const statusMap = {
           1: '启用',
@@ -202,39 +248,29 @@ import LinkPopover from '../../components/Link/linkPopover'
     },
     created() {
       // eslint-disable-next-line no-sequences
-      const queryParam = this.$route.query
-      if (queryParam && typeof queryParam === 'object' && queryParam.groupId) {
-        this.groupId = queryParam.groupId
-        localStorage.setItem('groupId', this.groupId)
-        this.getGroupOne()
-        this.getList()
-        return
+      if (this.$route.query.groupId) {
+          this.listQuery.groupId = this.$route.query.groupId
+      } else {
+          this.$notify({
+              title: '错误',
+              message: '没有获取到安全组信息',
+              type: 'error',
+              duration: 3000
+          })
+          this.$router.push(`/system/securityGroup`)
+          return
       }
-
-      const groupId = localStorage.getItem('groupId')
-      if (groupId) {
-        this.groupId = parseInt(groupId)
-        this.getGroupOne()
-        this.getList()
-        return
-      } 
-      
-      this.$notify({
-          title: '错误',
-          message: '没有获取到安全组信息',
-          type: 'error',
-          duration: 3000
-        })
-      this.$router.push(`/system/securityGroup`)
+      this.getGroupDetail()
+      this.getList()
     },
     methods: {
-      getGroupOne () {
-        fetchGroupOne(this.groupId).then(response => {
+      getGroupDetail () {
+        fetchGroupDetail({id: this.listQuery.groupId}).then(response => {
           this.group = response.data.data
         })
       },
       getList() {
-        if (!this.groupId) {
+        if (!this.listQuery.groupId) {
           this.$notify({
               title: '错误',
               message: '没有获取到安全组信息',
@@ -244,11 +280,24 @@ import LinkPopover from '../../components/Link/linkPopover'
           return
         }
         this.listLoading = true
-        fetchRuleList(this.groupId).then(response => {
-          this.list = response.data.data
+        fetchRulePage(this.listQuery).then(response => {
+          this.list = response.data.data.records
+          this.total = response.data.data.total
           this.listLoading = false
         })
       },
+      handleFilter() {
+        this.listQuery.current = 1
+        this.getList()
+      },
+      handleSizeChange(val) {
+        this.listQuery.size = val
+        this.getList()
+      },
+      handleCurrentChange(val) {
+        this.listQuery.current = val
+        this.getList()
+      },
       handleEnableStatus(row) {
         enableRule(row.id).then(response => {
           if (response.data.code === 0) {
@@ -271,15 +320,26 @@ import LinkPopover from '../../components/Link/linkPopover'
           }
         })
       },
+      handleModifyStatus(row, enable) {
+        updateRuleEnableStatus(row.id, enable).then(response => {
+          if (response.data.data.code === 0) {
+            this.$message({
+              message: '操作成功',
+              type: 'success'
+            })
+          }
+          this.getList()
+        })
+      },
       resetTemp() {
         this.temp = {
           id: undefined,
-          groupId: this.groupId,
+          groupId: this.listQuery.groupId,
           name: '',
           description: '',
           rule: '',
-          passType: this.group.defaultPassType == 'allow' ? 0 : 1,
-          passTypeTooltip: `安全组已设置默认${(this.group.defaultPassType == 'allow' ? '允许' : '拒绝')}`,
+          passType: this.group.defaultPassType == 1 ? 0 : 1,
+          passTypeTooltip: `安全组已设置默认${(this.group.defaultPassType == 1 ? '允许' : '拒绝')}`,
           priority: 1
         }
       },
@@ -294,7 +354,7 @@ import LinkPopover from '../../components/Link/linkPopover'
       createData() {
         this.$refs['dataForm'].validate((valid) => {
           if (valid) {
-            this.temp.groupId = this.groupId
+            this.temp.groupId = this.listQuery.groupId
             createRule(this.temp).then(response => {
               if (response.data.code === 0) {
                 this.dialogFormVisible = false
@@ -312,8 +372,8 @@ import LinkPopover from '../../components/Link/linkPopover'
       },
       handleUpdate(row) {
         this.temp = Object.assign({}, row) // copy obj
-        this.temp.passType = row.passType == 'allow' ? 1 : 0
-        this.temp.passTypeTooltip = `安全组已设置默认${(this.group.defaultPassType == 'allow' ? '允许' : '拒绝')}`,
+        this.temp.passType = row.passType
+        this.temp.passTypeTooltip = `安全组已设置默认${(this.group.defaultPassType == 1 ? '允许' : '拒绝')}`,
         this.temp.timestamp = new Date(this.temp.timestamp)
         this.dialogStatus = 'update'
         this.dialogFormVisible = true
@@ -325,7 +385,7 @@ import LinkPopover from '../../components/Link/linkPopover'
         this.$refs['dataForm'].validate((valid) => {
           if (valid) {
             const tempData = Object.assign({}, this.temp)
-            tempData.groupId = this.groupId
+            tempData.groupId = this.listQuery.groupId
             updateRule(tempData).then(response => {
               if (response.data.code === 0) {
                 this.$notify({
@@ -342,7 +402,7 @@ import LinkPopover from '../../components/Link/linkPopover'
         })
       },
       handleDelete(row) {
-        deleteRule(row.id).then(response => {
+        deleteRule({ruleId: row.id}).then(response => {
           if (response.data.code === 0) {
             this.$notify({
               title: '成功',

neutrino-proxy-admin/src/views/system/user.vue

@@ -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>

neutrino-proxy-client-sdk/Dockerfile

@@ -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

neutrino-proxy-client-sdk/pom.xml

@@ -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>

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/config/IProxyConfiguration.java

@@ -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();
+//    }
+
+}

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/config/ProxyConfig.java

@@ -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

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/constant/Constants.java

@@ -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

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/core/CmdChannelHandler.java

@@ -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>
             }
         }
     }
+
 }

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/core/CustomThreadFactory.java

@@ -19,7 +19,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-package org.dromara.neutrinoproxy.client.core;
+package org.dromara.neutrinoproxy.client.sdk.core;
 
 import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -35,9 +35,7 @@ public class CustomThreadFactory implements ThreadFactory {
 	private final String namePrefix;
 
 	public CustomThreadFactory(String prefix) {
-		SecurityManager s = System.getSecurityManager();
-		group = (s != null) ? s.getThreadGroup() :
-			Thread.currentThread().getThreadGroup();
+		group = Thread.currentThread().getThreadGroup();
 		namePrefix = prefix + "-thread-";
 	}
 

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/core/IAbProxyClientService.java

@@ -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);
+		}
+	}
+}

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/core/ProxyChannelBorrowListener.java

@@ -20,7 +20,7 @@
  * SOFTWARE.
  */
 
-package org.dromara.neutrinoproxy.client.core;
+package org.dromara.neutrinoproxy.client.sdk.core;
 
 import io.netty.channel.Channel;
 

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/core/RealServerChannelHandler.java

@@ -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;

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/core/TcpProxyChannelHandler.java

@@ -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()) {

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/core/UdpProxyChannelHandler.java

@@ -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()) {

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/core/UdpRealServerHandler.java

@@ -1,11 +1,11 @@
-package org.dromara.neutrinoproxy.client.core;
+package org.dromara.neutrinoproxy.client.sdk.core;
 
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.channel.socket.DatagramPacket;
 import lombok.extern.slf4j.Slf4j;
-import org.dromara.neutrinoproxy.client.constant.Constants;
-import org.dromara.neutrinoproxy.client.util.UdpChannelBindInfo;
+import org.dromara.neutrinoproxy.client.sdk.constant.Constants;
+import org.dromara.neutrinoproxy.client.sdk.util.UdpChannelBindInfo;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
 
 import java.net.InetSocketAddress;

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/handler/ProxyMessageAuthHandler.java

@@ -1,17 +1,15 @@
-package org.dromara.neutrinoproxy.client.handler;
+package org.dromara.neutrinoproxy.client.sdk.handler;
 
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
 import io.netty.channel.ChannelHandlerContext;
 import lombok.extern.slf4j.Slf4j;
-import org.dromara.neutrinoproxy.client.config.ProxyConfig;
+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
 import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.ExceptionEnum;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
 import org.dromara.neutrinoproxy.core.ProxyMessageHandler;
 import org.dromara.neutrinoproxy.core.dispatcher.Match;
-import org.noear.snack.ONode;
-import org.noear.solon.Solon;
-import org.noear.solon.annotation.Component;
-import org.noear.solon.annotation.Inject;
 
 /**
  * 认证信息处理器
@@ -20,22 +18,26 @@ import org.noear.solon.annotation.Inject;
  */
 @Slf4j
 @Match(type = Constants.ProxyDataTypeName.AUTH)
-@Component
 public class ProxyMessageAuthHandler implements ProxyMessageHandler {
-	@Inject
-	private ProxyConfig proxyConfig;
+	private final ProxyConfig proxyConfig;
+    private final Runnable stop;
+
+    public ProxyMessageAuthHandler(ProxyConfig proxyConfig,Runnable stop){
+        this.proxyConfig=proxyConfig;
+        this.stop=stop;
+    }
 	@Override
 	public void handle(ChannelHandlerContext context, ProxyMessage proxyMessage) {
 		String info = proxyMessage.getInfo();
-        ONode load = ONode.load(info);
-        Integer code = load.get("code").getInt();
+        JSONObject load = JSONUtil.parseObj(info);
+        Integer code = load.getInt("code");
 		log.info("Auth result:{}", info);
 		if (ExceptionEnum.AUTH_FAILED.getCode().equals(code)) {
 			// 客户端认证失败，直接停止服务
 			log.info("client auth failed , client stop.");
 			context.channel().close();
 			if (!proxyConfig.getTunnel().getReconnection().getUnlimited()) {
-				Solon.stop();
+				stop.run();
 			}
 		} else if (ExceptionEnum.CONNECT_FAILED.getCode().equals(code) ||
 				ExceptionEnum.LICENSE_CANNOT_REPEAT_CONNECT.getCode().equals(code)

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/handler/ProxyMessageConnectHandler.java

@@ -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();
+	}
+
+}

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/handler/ProxyMessageDisconnectHandler.java

@@ -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

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/handler/ProxyMessageErrorHandler.java

@@ -1,15 +1,11 @@
-package org.dromara.neutrinoproxy.client.handler;
+package org.dromara.neutrinoproxy.client.sdk.handler;
 
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
 import io.netty.channel.ChannelHandlerContext;
 import lombok.extern.slf4j.Slf4j;
-import org.dromara.neutrinoproxy.core.Constants;
-import org.dromara.neutrinoproxy.core.ExceptionEnum;
-import org.dromara.neutrinoproxy.core.ProxyDataTypeEnum;
-import org.dromara.neutrinoproxy.core.ProxyMessage;
-import org.dromara.neutrinoproxy.core.ProxyMessageHandler;
+import org.dromara.neutrinoproxy.core.*;
 import org.dromara.neutrinoproxy.core.dispatcher.Match;
-import org.noear.snack.ONode;
-import org.noear.solon.annotation.Component;
 
 /**
  * 异常信息处理器
@@ -18,14 +14,13 @@ import org.noear.solon.annotation.Component;
  */
 @Slf4j
 @Match(type = Constants.ProxyDataTypeName.ERROR)
-@Component
 public class ProxyMessageErrorHandler implements ProxyMessageHandler {
 
 	@Override
 	public void handle(ChannelHandlerContext ctx, ProxyMessage proxyMessage) {
 		log.info("error: {}", proxyMessage.getInfo());
-        ONode load = ONode.load(proxyMessage.getInfo());
-        Integer code = load.get("code").getInt();
+        JSONObject load = JSONUtil.parseObj(proxyMessage.getInfo());
+        Integer code = load.getInt("code");
 		if (ExceptionEnum.AUTH_FAILED.getCode().equals(code)) {
 			System.exit(0);
 		}
@@ -35,4 +30,5 @@ public class ProxyMessageErrorHandler implements ProxyMessageHandler {
 	public String name() {
 		return ProxyDataTypeEnum.DISCONNECT.getDesc();
 	}
+
 }

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/handler/ProxyMessageFactory.java

@@ -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());
+    }
+}

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/handler/ProxyMessageTransferHandler.java

@@ -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

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/handler/UdpProxyMessageConnectHandler.java

@@ -1,20 +1,18 @@
-package org.dromara.neutrinoproxy.client.handler;
+package org.dromara.neutrinoproxy.client.sdk.handler;
 
+import cn.hutool.json.JSONUtil;
 import io.netty.bootstrap.Bootstrap;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import lombok.extern.slf4j.Slf4j;
-import org.dromara.neutrinoproxy.client.config.ProxyConfig;
-import org.dromara.neutrinoproxy.client.core.ProxyChannelBorrowListener;
-import org.dromara.neutrinoproxy.client.util.ProxyUtil;
+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
+import org.dromara.neutrinoproxy.client.sdk.core.ProxyChannelBorrowListener;
+import org.dromara.neutrinoproxy.client.sdk.util.ProxyUtil;
 import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.ProxyDataTypeEnum;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
 import org.dromara.neutrinoproxy.core.ProxyMessageHandler;
 import org.dromara.neutrinoproxy.core.dispatcher.Match;
-import org.noear.snack.ONode;
-import org.noear.solon.annotation.Component;
-import org.noear.solon.annotation.Inject;
 
 /**
  * @author: aoshiguchen
@@ -22,17 +20,21 @@ import org.noear.solon.annotation.Inject;
  */
 @Slf4j
 @Match(type = Constants.ProxyDataTypeName.UDP_CONNECT)
-@Component
 public class UdpProxyMessageConnectHandler implements ProxyMessageHandler {
-    @Inject
-    private ProxyConfig proxyConfig;
-    @Inject("udpProxyTunnelBootstrap")
-    private Bootstrap udpProxyTunnelBootstrap;
+
+    private final ProxyConfig proxyConfig;
+    private final Bootstrap udpProxyTunnelBootstrap;
+
+    public UdpProxyMessageConnectHandler(ProxyConfig proxyConfig,Bootstrap udpProxyTunnelBootstrap){
+        this.proxyConfig=proxyConfig;
+        this.udpProxyTunnelBootstrap=udpProxyTunnelBootstrap;
+    }
 
     @Override
     public void handle(ChannelHandlerContext ctx, ProxyMessage proxyMessage) {
         final Channel cmdChannel = ctx.channel();
-        final ProxyMessage.UdpBaseInfo udpBaseInfo = ONode.deserialize(proxyMessage.getInfo(), ProxyMessage.UdpBaseInfo.class);
+        String info = proxyMessage.getInfo();
+        final ProxyMessage.UdpBaseInfo udpBaseInfo = JSONUtil.toBean(info,ProxyMessage.UdpBaseInfo.class);
         log.info("[UDP connect]info:{}", proxyMessage.getInfo());
 
         // 获取连接
@@ -61,4 +63,5 @@ public class UdpProxyMessageConnectHandler implements ProxyMessageHandler {
     public String name() {
         return ProxyDataTypeEnum.UDP_CONNECT.getDesc();
     }
+
 }

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/handler/UdpProxyMessageTransferHandler.java

@@ -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();
     }
+
 }

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/util/LockChannel.java

@@ -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;

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/util/ProxyUtil.java

@@ -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;

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/util/UdpChannelBindInfo.java

@@ -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;

neutrino-proxy-client-sdk/src/main/java/org/dromara/neutrinoproxy/client/sdk/util/UdpServerUtil.java

@@ -1,4 +1,4 @@
-package org.dromara.neutrinoproxy.client.util;
+package org.dromara.neutrinoproxy.client.sdk.util;
 
 import io.netty.bootstrap.Bootstrap;
 import io.netty.buffer.Unpooled;
@@ -7,11 +7,11 @@ import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelFutureListener;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
-import org.dromara.neutrinoproxy.client.config.ProxyConfig;
-import org.dromara.neutrinoproxy.client.constant.Constants;
-import org.dromara.neutrinoproxy.client.core.CustomThreadFactory;
+import org.dromara.neutrinoproxy.client.sdk.config.ProxyConfig;
+import org.dromara.neutrinoproxy.client.sdk.constant.Constants;
+import org.dromara.neutrinoproxy.client.sdk.core.CustomThreadFactory;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
-import org.noear.solon.core.runtime.NativeDetector;
+import java.util.concurrent.TimeUnit;
 
 import java.util.*;
 import java.util.concurrent.*;
@@ -46,9 +46,9 @@ public class UdpServerUtil {
      * 2、维护一个UDP服务池，用于需要响应的UDP转发
      * @param proxyConfig
      */
-    public static void initCache(ProxyConfig proxyConfig, Bootstrap udpServerBootstrap) {
+    public static void initCache(ProxyConfig proxyConfig, Bootstrap udpServerBootstrap,Boolean isAotRuntime) {
         // aot 阶段，不初始化UDP服务
-        if (NativeDetector.isAotRuntime()) {
+        if (isAotRuntime) {
             return;
         }
         if (null == proxyConfig.getClient().getUdp() || StringUtils.isEmpty(proxyConfig.getClient().getUdp().getPuppetPortRange())) {

neutrino-proxy-client/pom.xml

@@ -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>

neutrino-proxy-client/src/main/java/org/dromara/neutrinoproxy/client/ProxyClient.java

@@ -28,7 +28,9 @@ public class ProxyClient {
 			setAlias("neutrino.proxy.tunnel.jks-path", "jksPath");
 			setAlias("neutrino.proxy.tunnel.key-store-password", "keyStorePassword");
 			setAlias("neutrino.proxy.tunnel.license-key", "licenseKey");
-		});
+
+            log.info("NeutrinoProxy Client ：{}", app.cfg().get("solon.app.version"));
+        });
 	}
 
 	/**

neutrino-proxy-client/src/main/java/org/dromara/neutrinoproxy/client/config/NeutrinoClientRuntimeNativeRegistrar.java

@@ -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);
+
     }
 }

neutrino-proxy-client/src/main/java/org/dromara/neutrinoproxy/client/config/ProxyConfiguration.java

@@ -1,30 +1,11 @@
 package org.dromara.neutrinoproxy.client.config;
 
-import io.netty.channel.ChannelInitializer;
-import io.netty.channel.ChannelOption;
-import io.netty.channel.ChannelPipeline;
-import io.netty.channel.nio.NioEventLoopGroup;
-import io.netty.channel.socket.SocketChannel;
-import io.netty.channel.socket.nio.NioDatagramChannel;
-import io.netty.channel.socket.nio.NioSocketChannel;
-import io.netty.handler.logging.LoggingHandler;
-import io.netty.handler.timeout.IdleStateHandler;
-import org.dromara.neutrinoproxy.client.core.*;
-import org.dromara.neutrinoproxy.client.util.ProxyUtil;
-import org.dromara.neutrinoproxy.core.*;
+import org.dromara.neutrinoproxy.client.sdk.handler.ProxyMessageFactory;
 import org.dromara.neutrinoproxy.core.aot.NeutrinoCoreRuntimeNativeRegistrar;
-import org.dromara.neutrinoproxy.core.dispatcher.DefaultDispatcher;
-import org.dromara.neutrinoproxy.core.dispatcher.Dispatcher;
-import io.netty.bootstrap.Bootstrap;
-import io.netty.channel.ChannelHandlerContext;
 import org.noear.solon.Solon;
 import org.noear.solon.annotation.Bean;
 import org.noear.solon.annotation.Configuration;
-import org.noear.solon.annotation.Inject;
-import org.noear.solon.core.bean.LifecycleBean;
-
-import java.net.InetSocketAddress;
-import java.util.List;
+import org.noear.solon.core.runtime.NativeDetector;
 
 /**
  * 代理配置
@@ -32,182 +13,20 @@ import java.util.List;
  * @date: 2022/10/8
  */
 @Configuration
-public class ProxyConfiguration implements LifecycleBean {
+public class ProxyConfiguration extends ProxyMessageFactory {
 
     @Override
-    public void start() throws Throwable {
-        List<ProxyMessageHandler> list = Solon.context().getBeansOfType(ProxyMessageHandler.class);
-        Dispatcher<ChannelHandlerContext, ProxyMessage> dispatcher = new DefaultDispatcher<>("MessageDispatcher", list,
-                proxyMessage -> ProxyDataTypeEnum.of((int)proxyMessage.getType()) == null ?
-                        null : ProxyDataTypeEnum.of((int)proxyMessage.getType()).getName());
-        Solon.context().wrapAndPut(Dispatcher.class, dispatcher);
+    public void stop() {
+        Solon.stop();
     }
 
-    @Bean("tunnelWorkGroup")
-    public NioEventLoopGroup tunnelWorkGroup(@Inject ProxyConfig proxyConfig) {
-        return new NioEventLoopGroup(proxyConfig.getTunnel().getThreadCount());
-    }
-
-    @Bean("tcpRealServerWorkGroup")
-    public NioEventLoopGroup tcpRealServerWorkGroup(@Inject ProxyConfig proxyConfig) {
-        // 暂时先公用此配置
-        return new NioEventLoopGroup(proxyConfig.getTunnel().getThreadCount());
-    }
-
-    @Bean("udpServerGroup")
-    public NioEventLoopGroup udpServerGroup(@Inject ProxyConfig proxyConfig) {
-        // 暂时先公用此配置
-        return new NioEventLoopGroup(proxyConfig.getClient().getUdp().getBossThreadCount());
-    }
-
-    @Bean("udpWorkGroup")
-    public NioEventLoopGroup udpWorkGroup(@Inject ProxyConfig proxyConfig) {
-        // 暂时先公用此配置
-        return new NioEventLoopGroup(proxyConfig.getClient().getUdp().getWorkThreadCount());
-    }
-
-    @Bean("cmdTunnelBootstrap")
-    public Bootstrap cmdTunnelBootstrap(@Inject ProxyConfig proxyConfig,
-                                        @Inject("tunnelWorkGroup") NioEventLoopGroup tunnelWorkGroup) {
-        Bootstrap bootstrap = new Bootstrap();
-        bootstrap.group(tunnelWorkGroup);
-        bootstrap.channel(NioSocketChannel.class);
-//		bootstrap.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000);
-//		bootstrap.option(ChannelOption.SO_KEEPALIVE, true);
-//		/**
-//		 * TCP/IP协议中，无论发送多少数据，总是要在数据前面加上协议头，同时，对方接收到数据，也需要发送ACK表示确认。为了尽可能的利用网络带宽，TCP总是希望尽可能的发送足够大的数据。（一个连接会设置MSS参数，因此，TCP/IP希望每次都能够以MSS尺寸的数据块来发送数据）。
-//		 * Nagle算法就是为了尽可能发送大块数据，避免网络中充斥着许多小数据块。
-//		 */
-//		bootstrap.option(ChannelOption.TCP_NODELAY, true);
-        bootstrap.remoteAddress(InetSocketAddress.createUnresolved(proxyConfig.getTunnel().getServerIp(), proxyConfig.getTunnel().getServerPort()));
-
-        bootstrap.handler(new ChannelInitializer<SocketChannel>() {
-
-            @Override
-            public void initChannel(SocketChannel ch) throws Exception {
-                if (proxyConfig.getTunnel().getSslEnable()) {
-                    ch.pipeline().addLast(ProxyUtil.createSslHandler(proxyConfig));
-                }
-                if (null != proxyConfig.getTunnel().getTransferLogEnable() && proxyConfig.getTunnel().getTransferLogEnable()) {
-                    ch.pipeline().addFirst(new LoggingHandler(CmdChannelHandler.class));
-                }
-                ch.pipeline().addLast(new ProxyMessageDecoder(proxyConfig.getProtocol().getMaxFrameLength(),
-                        proxyConfig.getProtocol().getLengthFieldOffset(), proxyConfig.getProtocol().getLengthFieldLength(),
-                        proxyConfig.getProtocol().getLengthAdjustment(), proxyConfig.getProtocol().getInitialBytesToStrip()));
-                ch.pipeline().addLast(new ProxyMessageEncoder());
-                ch.pipeline().addLast(new IdleStateHandler(proxyConfig.getProtocol().getReadIdleTime(), proxyConfig.getProtocol().getWriteIdleTime(), proxyConfig.getProtocol().getAllIdleTimeSeconds()));
-                ch.pipeline().addLast(new CmdChannelHandler());
-            }
-        });
-        return bootstrap;
-    }
-
-    @Bean("tcpProxyTunnelBootstrap")
-    public Bootstrap tcpProxyTunnelBootstrap(@Inject ProxyConfig proxyConfig,
-                                             @Inject("tunnelWorkGroup") NioEventLoopGroup tunnelWorkGroup) {
-        Bootstrap bootstrap = new Bootstrap();
-        bootstrap.group(tunnelWorkGroup);
-        bootstrap.channel(NioSocketChannel.class);
-        bootstrap.remoteAddress(InetSocketAddress.createUnresolved(proxyConfig.getTunnel().getServerIp(), proxyConfig.getTunnel().getServerPort()));
-        bootstrap.handler(new ChannelInitializer<SocketChannel>() {
-
-            @Override
-            public void initChannel(SocketChannel ch) throws Exception {
-                if (proxyConfig.getTunnel().getSslEnable()) {
-                    ch.pipeline().addLast(ProxyUtil.createSslHandler(proxyConfig));
-                }
-                if (null != proxyConfig.getTunnel().getTransferLogEnable() && proxyConfig.getTunnel().getTransferLogEnable()) {
-                    ch.pipeline().addFirst(new LoggingHandler(TcpProxyChannelHandler.class));
-                }
-                ch.pipeline().addLast(new ProxyMessageDecoder(proxyConfig.getProtocol().getMaxFrameLength(),
-                        proxyConfig.getProtocol().getLengthFieldOffset(), proxyConfig.getProtocol().getLengthFieldLength(),
-                        proxyConfig.getProtocol().getLengthAdjustment(), proxyConfig.getProtocol().getInitialBytesToStrip()));
-                ch.pipeline().addLast(new ProxyMessageEncoder());
-                ch.pipeline().addLast(new IdleStateHandler(proxyConfig.getProtocol().getReadIdleTime(), proxyConfig.getProtocol().getWriteIdleTime(), proxyConfig.getProtocol().getAllIdleTimeSeconds()));
-                ch.pipeline().addLast(new TcpProxyChannelHandler());
-            }
-        });
-        return bootstrap;
-    }
-
-    @Bean("udpProxyTunnelBootstrap")
-    public Bootstrap udpProxyTunnelBootstrap(@Inject ProxyConfig proxyConfig,
-                                              @Inject("tunnelWorkGroup") NioEventLoopGroup tunnelWorkGroup) {
-        Bootstrap bootstrap = new Bootstrap();
-        bootstrap.group(tunnelWorkGroup);
-        bootstrap.channel(NioSocketChannel.class);
-        bootstrap.remoteAddress(InetSocketAddress.createUnresolved(proxyConfig.getTunnel().getServerIp(), proxyConfig.getTunnel().getServerPort()));
-        bootstrap.handler(new ChannelInitializer<SocketChannel>() {
-
-            @Override
-            public void initChannel(SocketChannel ch) throws Exception {
-                if (proxyConfig.getTunnel().getSslEnable()) {
-                    ch.pipeline().addLast(ProxyUtil.createSslHandler(proxyConfig));
-                }
-                if (null != proxyConfig.getTunnel().getTransferLogEnable() && proxyConfig.getTunnel().getTransferLogEnable()) {
-                    ch.pipeline().addFirst(new LoggingHandler(TcpProxyChannelHandler.class));
-                }
-                ch.pipeline().addLast(new ProxyMessageDecoder(proxyConfig.getProtocol().getMaxFrameLength(),
-                        proxyConfig.getProtocol().getLengthFieldOffset(), proxyConfig.getProtocol().getLengthFieldLength(),
-                        proxyConfig.getProtocol().getLengthAdjustment(), proxyConfig.getProtocol().getInitialBytesToStrip()));
-                ch.pipeline().addLast(new ProxyMessageEncoder());
-                ch.pipeline().addLast(new IdleStateHandler(proxyConfig.getProtocol().getReadIdleTime(), proxyConfig.getProtocol().getWriteIdleTime(), proxyConfig.getProtocol().getAllIdleTimeSeconds()));
-                ch.pipeline().addLast(new UdpProxyChannelHandler());
-            }
-        });
-        return bootstrap;
-    }
-
-    @Bean("realServerBootstrap")
-    public Bootstrap realServerBootstrap(@Inject ProxyConfig proxyConfig,
-                                             @Inject("tcpRealServerWorkGroup") NioEventLoopGroup tcpRealServerWorkGroup
-                                             ) {
-        Bootstrap bootstrap = new Bootstrap();
-        bootstrap.group(tcpRealServerWorkGroup);
-        bootstrap.channel(NioSocketChannel.class);
-        bootstrap.handler(new ChannelInitializer<SocketChannel>() {
-
-            @Override
-            public void initChannel(SocketChannel ch) throws Exception {
-                if (null != proxyConfig.getTunnel().getTransferLogEnable() && proxyConfig.getTunnel().getTransferLogEnable()) {
-                    ch.pipeline().addFirst(new LoggingHandler(RealServerChannelHandler.class));
-                }
-                ch.pipeline().addLast(new RealServerChannelHandler());
-            }
-        });
-        return bootstrap;
-    }
-
-    @Bean("udpServerBootstrap")
-    public Bootstrap udpServerBootstrap(@Inject ProxyConfig proxyConfig,
-                                        @Inject("udpServerGroup") NioEventLoopGroup udpServerGroup,
-                                        @Inject("udpWorkGroup") NioEventLoopGroup udpWorkGroup) {
-        Bootstrap bootstrap = new Bootstrap();
-        bootstrap.group(udpServerGroup)
-                // 主线程处理
-                .channel(NioDatagramChannel.class)
-                // 广播
-                .option(ChannelOption.SO_BROADCAST, true)
-                // 设置读缓冲区为2M
-                .option(ChannelOption.SO_RCVBUF, 2048 * 1024)
-                // 设置写缓冲区为1M
-                .option(ChannelOption.SO_SNDBUF, 1024 * 1024)
-                .handler(new ChannelInitializer<NioDatagramChannel>() {
-                    @Override
-                    protected void initChannel(NioDatagramChannel ch) {
-                        ChannelPipeline pipeline = ch.pipeline();
-                        if (null != proxyConfig.getClient().getUdp().getTransferLogEnable() && proxyConfig.getClient().getUdp().getTransferLogEnable()) {
-                            ch.pipeline().addFirst(new LoggingHandler(UdpRealServerHandler.class));
-                        }
-                        pipeline.addLast(udpWorkGroup, new UdpRealServerHandler());
-                    }
-                });
-        return bootstrap;
+    @Override
+    public boolean isAotRuntime() {
+        return NativeDetector.isAotRuntime();
     }
 
     @Bean
-    public NeutrinoCoreRuntimeNativeRegistrar neutrinoCoreRuntimeNativeRegistrar() {
+    public NeutrinoCoreRuntimeNativeRegistrar neutrinoCoreRuntimeNativeRegistrar(){
         return new NeutrinoCoreRuntimeNativeRegistrar();
     }
-
 }

neutrino-proxy-client/src/main/java/org/dromara/neutrinoproxy/client/config/SolonProxyConfig.java

@@ -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;
+	}
+}

neutrino-proxy-client/src/main/java/org/dromara/neutrinoproxy/client/core/ProxyClientService.java

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

neutrino-proxy-client/src/main/java/org/dromara/neutrinoproxy/client/handler/ProxyMessageConnectHandler.java

@@ -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();
-	}
-}

neutrino-proxy-client/src/main/resources/app-copy.yml

@@ -8,8 +8,8 @@ neutrino:
       # 线程池相关配置，用于技术调优，可忽略
       thread-count: 50
       # 隧道SSL证书配置
-      key-store-password: ${STORE_PASS:123456}
-      jks-path: ${JKS_PATH:classpath:/test.jks}
+      key-store-password: 123456
+      jks-path: classpath:/test.jks
       # 服务端IP
       server-ip: ${SERVER_IP:localhost}
       # 服务端端口(对应服务端app.yml中的tunnel.port、tunnel.ssl-port)
@@ -19,11 +19,11 @@ neutrino:
       # 客户端连接唯一凭证
       license-key: ${LICENSE_KEY:}
       # 客户端唯一身份标识（可忽略，若不设置首次启动会自动生成）
-      client-id: ${CLIENT_ID:}
+      client-id:
       # 是否开启隧道传输报文日志(日志级别为debug时开启才有效)
-      transfer-log-enable: ${CLIENT_LOG:false}
+      transfer-log-enable: false
       # 是否开启心跳日志
-      heartbeat-log-enable: ${HEARTBEAT_LOG:false}
+      heartbeat-log-enable: false
       # 重连设置
       reconnection:
         # 重连间隔（秒）
@@ -38,4 +38,4 @@ neutrino:
         # udp傀儡端口范围
         puppet-port-range: 10000-10500
         # 是否开启隧道传输报文日志(日志级别为debug时开启才有效)
-        transfer-log-enable: ${CLIENT_LOG:false}
+        transfer-log-enable: false

neutrino-proxy-client/src/main/resources/app.yml

@@ -3,7 +3,7 @@ solon:
     add: ./app.yml
   app:
     name: neutrino-proxy-client
-    version: @revision@
+    version: 2.0.1
 # 日志级别
 solon.logging.appender:
   console:
@@ -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对应上)

neutrino-proxy-core/src/main/java/org/dromara/neutrinoproxy/core/Constants.java

@@ -49,6 +49,12 @@ public interface Constants {
     AttributeKey<Boolean> IS_UDP_KEY =  AttributeKey.newInstance("isUdp");
     AttributeKey<InetSocketAddress> SENDER = AttributeKey.newInstance("sender");
 
+    AttributeKey<Integer> SERVER_PORT = AttributeKey.newInstance("serverPort");
+    AttributeKey<String> REAL_REMOTE_IP = AttributeKey.newInstance("realRemoteIp");
+
+
+    AttributeKey<Boolean> FLOW_LIMITER_FLAG = AttributeKey.newInstance("flowLimiterFlag");
+
 
     int HEADER_SIZE = 4;
     int TYPE_SIZE = 1;

neutrino-proxy-core/src/main/java/org/dromara/neutrinoproxy/core/aot/NeutrinoCoreRuntimeNativeRegistrar.java

@@ -8,6 +8,7 @@ import org.noear.solon.aot.RuntimeNativeRegistrar;
 import org.noear.solon.aot.hint.MemberCategory;
 import org.noear.solon.core.AppContext;
 
+import java.nio.ByteBuffer;
 import java.util.Set;
 
 /**
@@ -22,6 +23,11 @@ public class NeutrinoCoreRuntimeNativeRegistrar implements RuntimeNativeRegistra
             metadata.registerReflection(clazz, MemberCategory.INVOKE_DECLARED_METHODS);
         }
 
+        Set<Class<?>> byteBufferClasses = ClassUtil.scanPackageBySuper("java", ByteBuffer.class);
+        for (Class<?> clazz : byteBufferClasses) {
+            metadata.registerReflection(clazz, MemberCategory.INVOKE_DECLARED_METHODS);
+        }
+
         metadata.registerReflection(ProxyMessage.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_DECLARED_METHODS, MemberCategory.INVOKE_DECLARED_CONSTRUCTORS);
         metadata.registerReflection(ProxyMessage.UdpBaseInfo.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_DECLARED_METHODS, MemberCategory.INVOKE_DECLARED_CONSTRUCTORS);
 

neutrino-proxy-core/src/main/java/org/dromara/neutrinoproxy/core/util/HttpUtil.java

@@ -0,0 +1,60 @@
+package org.dromara.neutrinoproxy.core.util;
+
+
+import org.apache.commons.lang3.StringUtils;
+
+/**
+ * @author: wen.y
+ * @date: 2023/12/9
+ */
+public class HttpUtil {
+
+    /**
+     * 获取请求头 Host 忽略端口号
+     * @param httpContent
+     * @return
+     */
+    public static String getHostIgnorePort(String httpContent) {
+        String host = getHost(httpContent);
+        if (StringUtils.isEmpty(host) || !host.contains(":")) {
+            return host;
+        }
+        return host.replaceAll(":.*", "");
+    }
+
+    /**
+     * 获取请求头 Host
+     * @param httpContent
+     * @return
+     */
+    public static String getHost(String httpContent) {
+        return getHeaderValue(httpContent, "Host");
+    }
+
+    /**
+     * 获取请求头
+     * @param httpContent
+     * @return
+     */
+    public static String getHeaderValue(String httpContent, String header) {
+        String headerContent = httpContent.split("\r\n\r\n")[0];
+        String[] lines = headerContent.split("\r\n");
+        String firstLine = lines[0];
+        if (!(firstLine.endsWith("HTTP/1.1") || firstLine.endsWith("HTTP/1.0"))) {
+            return null;
+        }
+        for (int i = 1; i < lines.length; i++) {
+            String line = lines[i];
+            if (!line.startsWith(header + ":")) {
+                continue;
+            }
+            if (line.length() > header.length() + 1) {
+                return line.substring(header.length() + 1).trim();
+            } else {
+                return "";
+            }
+        }
+        return null;
+    }
+
+}

neutrino-proxy-core/src/main/java/org/dromara/neutrinoproxy/core/util/IpUtil.java

@@ -1,9 +1,13 @@
 package org.dromara.neutrinoproxy.core.util;
 
+import cn.hutool.core.net.Ipv4Util;
 import io.netty.channel.ChannelHandlerContext;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
 
 import java.net.InetSocketAddress;
 
+@Slf4j
 public class IpUtil extends org.noear.solon.core.util.IpUtil {
 
     public static String getRemoteIp(ChannelHandlerContext ctx) {
@@ -15,4 +19,21 @@ public class IpUtil extends org.noear.solon.core.util.IpUtil {
         return remoteAddress;
     }
 
+    /**
+     * 工作原理为从http协议的header中找公网地址，此主要用于处理nginx转发时塞进去的真实IP的header，找不到返回null
+     * @param httpContent http协议文档内容
+     * @return 返回找到的第一个公网地址
+     */
+    public static String getRealRemoteIp(String httpContent) {
+        String ip = HttpUtil.getHeaderValue(httpContent, "X-Forwarded-For");
+        if (StringUtils.isEmpty(ip)) {
+            ip = HttpUtil.getHeaderValue(httpContent, "X-Real-IP");
+        }
+        if (StringUtils.isNotEmpty(ip)) {
+            log.debug("obtain http header ip：{}", ip);
+            return ip;
+        }
+        return null;
+    }
+
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/ProxyServer.java

@@ -2,7 +2,6 @@ package org.dromara.neutrinoproxy.server;
 
 import lombok.extern.slf4j.Slf4j;
 import org.dromara.solonplugins.job.annotation.EnableJob;
-import org.noear.snack.core.utils.StringUtil;
 import org.noear.solon.Solon;
 import org.noear.solon.Utils;
 import org.noear.solon.annotation.SolonMain;
@@ -26,6 +25,7 @@ public class ProxyServer {
             if (Utils.isNotEmpty(loglevel)) {
                 app.cfg().put("solon.logging.logger.root.level", loglevel);
             }
+            log.info("NeutrinoProxy Server ：{}", app.cfg().get("solon.app.version"));
 		});
 	}
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/base/NeutrinoServerRuntimeNativeRegistrar.java

@@ -1,30 +1,11 @@
 package org.dromara.neutrinoproxy.server.base;
 
+import org.apache.ibatis.type.SimpleTypeRegistry;
 import org.dromara.neutrinoproxy.server.base.proxy.ProxyConfig;
 import org.dromara.neutrinoproxy.server.base.rest.ResponseBody;
 import org.dromara.neutrinoproxy.server.controller.res.report.HomeDataView;
-import org.dromara.neutrinoproxy.server.dal.ClientConnectRecordMapper;
-import org.dromara.neutrinoproxy.server.dal.FlowReportDayMapper;
-import org.dromara.neutrinoproxy.server.dal.FlowReportHourMapper;
-import org.dromara.neutrinoproxy.server.dal.FlowReportMinuteMapper;
-import org.dromara.neutrinoproxy.server.dal.FlowReportMonthMapper;
-import org.dromara.neutrinoproxy.server.dal.JobInfoMapper;
-import org.dromara.neutrinoproxy.server.dal.LicenseMapper;
-import org.dromara.neutrinoproxy.server.dal.PortMappingMapper;
-import org.dromara.neutrinoproxy.server.dal.PortPoolMapper;
-import org.dromara.neutrinoproxy.server.dal.UserLoginRecordMapper;
-import org.dromara.neutrinoproxy.server.dal.UserMapper;
-import org.dromara.neutrinoproxy.server.dal.UserTokenMapper;
-import org.dromara.neutrinoproxy.server.service.ClientConnectRecordService;
-import org.dromara.neutrinoproxy.server.service.JobInfoService;
-import org.dromara.neutrinoproxy.server.service.JobLogService;
-import org.dromara.neutrinoproxy.server.service.LicenseService;
-import org.dromara.neutrinoproxy.server.service.PortGroupService;
-import org.dromara.neutrinoproxy.server.service.PortMappingService;
-import org.dromara.neutrinoproxy.server.service.PortPoolService;
-import org.dromara.neutrinoproxy.server.service.ReportService;
-import org.dromara.neutrinoproxy.server.service.UserLoginRecordService;
-import org.dromara.neutrinoproxy.server.service.UserService;
+import org.dromara.neutrinoproxy.server.dal.*;
+import org.dromara.neutrinoproxy.server.service.*;
 import org.dromara.solonplugins.job.JobBean;
 import org.noear.solon.annotation.Component;
 import org.noear.solon.aot.RuntimeNativeMetadata;
@@ -56,6 +37,8 @@ public class NeutrinoServerRuntimeNativeRegistrar implements RuntimeNativeRegist
         metadata.registerLambdaSerialization(ReportService.class);
         metadata.registerLambdaSerialization(UserLoginRecordService.class);
         metadata.registerLambdaSerialization(UserService.class);
+        metadata.registerLambdaSerialization(SecurityGroupService.class);
+
 
         metadata.registerLambdaSerialization(LicenseMapper.class);
         metadata.registerLambdaSerialization(ClientConnectRecordMapper.class);
@@ -64,11 +47,17 @@ public class NeutrinoServerRuntimeNativeRegistrar implements RuntimeNativeRegist
         metadata.registerLambdaSerialization(FlowReportMinuteMapper.class);
         metadata.registerLambdaSerialization(FlowReportMonthMapper.class);
         metadata.registerLambdaSerialization(JobInfoMapper.class);
+        metadata.registerLambdaSerialization(JobLogMapper.class);
         metadata.registerLambdaSerialization(PortMappingMapper.class);
+        metadata.registerLambdaSerialization(PortGroupMapper.class);
+        metadata.registerLambdaSerialization(ReportMapper.class);
         metadata.registerLambdaSerialization(PortPoolMapper.class);
         metadata.registerLambdaSerialization(UserLoginRecordMapper.class);
         metadata.registerLambdaSerialization(UserMapper.class);
         metadata.registerLambdaSerialization(UserTokenMapper.class);
+        metadata.registerLambdaSerialization(SecurityGroupMapper.class);
+        metadata.registerLambdaSerialization(SecurityRuleMapper.class);
+
 
         metadata.registerReflection(HomeDataView.class, MemberCategory.DECLARED_FIELDS);
         metadata.registerReflection(HomeDataView.Last7dFlow.class, MemberCategory.DECLARED_FIELDS);
@@ -90,6 +79,8 @@ public class NeutrinoServerRuntimeNativeRegistrar implements RuntimeNativeRegist
 
         metadata.registerReflection(JobBean.class, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS);
 
+        // 解决mybatis调用deleteBatchIds报错“java.lang.ClassNotFoundException: Cannot find class: org.apache.ibatis.type.SimpleTypeRegistry”
+        metadata.registerReflection(SimpleTypeRegistry.class, MemberCategory.DECLARED_FIELDS, MemberCategory.INVOKE_PUBLIC_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS);
     }
 
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/base/proxy/ProxyConfiguration.java

@@ -20,6 +20,9 @@ import io.netty.channel.nio.NioEventLoopGroup;
 import org.dromara.neutrinoproxy.server.proxy.core.BytesMetricsHandler;
 import org.dromara.neutrinoproxy.server.proxy.core.TcpVisitorChannelHandler;
 import org.dromara.neutrinoproxy.server.proxy.core.UdpVisitorChannelHandler;
+import org.dromara.neutrinoproxy.server.proxy.security.TcpVisitorSecurityChannelHandler;
+import org.dromara.neutrinoproxy.server.proxy.security.UdpVisitorSecurityChannelHandler;
+import org.dromara.neutrinoproxy.server.proxy.security.VisitorFlowLimiterChannelHandler;
 import org.noear.solon.Solon;
 import org.noear.solon.annotation.Bean;
 import org.noear.solon.annotation.Configuration;
@@ -74,6 +77,8 @@ public class ProxyConfiguration implements LifecycleBean {
             }
             ch.pipeline().addFirst(new BytesMetricsHandler());
 //            ch.pipeline().addLast(new ChannelTrafficShapingHandler(1024 * 1024 * 20, 1024 * 1024 * 20, 100, 20000));
+            ch.pipeline().addLast(new TcpVisitorSecurityChannelHandler());
+            ch.pipeline().addLast("flowLimiter", new VisitorFlowLimiterChannelHandler());
             ch.pipeline().addLast(new TcpVisitorChannelHandler());
             }
         });
@@ -111,6 +116,8 @@ public class ProxyConfiguration implements LifecycleBean {
                     if (null != proxyConfig.getServer().getUdp().getTransferLogEnable() && proxyConfig.getServer().getUdp().getTransferLogEnable()) {
                         ch.pipeline().addFirst(new LoggingHandler(UdpVisitorChannelHandler.class));
                     }
+                    pipeline.addLast(udpServerWorkerGroup, new UdpVisitorSecurityChannelHandler());
+                    ch.pipeline().addLast("flowLimiter", new VisitorFlowLimiterChannelHandler());
                     pipeline.addLast(udpServerWorkerGroup, new UdpVisitorChannelHandler());
                 }
             });

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/constant/ExceptionConstant.java

@@ -40,8 +40,8 @@ public enum ExceptionConstant {
 	NO_PERMISSION_VISIT(5, "当前用户无权访问该资源"),
 	PARAMS_NOT_NULL(10, "参数[{}]不能为空"),
 	PARAMS_NOT_EMPTY(11, "参数[{}]不能为空"),
-
 	FILED_LENGTH_OUT(12 ,"{}不能超出长度{}"),
+    BYTES_DESC_INVALID(13, "参数[{}]字节描述不合法"),
 
 	// 用户管理(11000)
 	// license管理(12000)
@@ -67,7 +67,12 @@ public enum ExceptionConstant {
 
 	PORT_GROUP_NAME_ALREADY_EXIST(16000,"端口分组名称[{}]已经存在"),
 	PORT_GROUP_NAME_DOES_NOT_EXIST(16001,"端口分组不存在"),
-	DEFAULT_GROUP_FORBID_DELETE(16002,"默认分组禁止删除")
+	DEFAULT_GROUP_FORBID_DELETE(16002,"默认分组禁止删除"),
+
+    // 安全组管理(17000)
+    SECURITY_GROUP_NOT_EXIST(17000, "安全组不存在"),
+	SECURITY_RULE_NOT_EXIST(17001, "安全规则不存在"),
+
 	;
 
 	private int code;

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/constant/SecurityRulePassTypeEnum.java

@@ -11,6 +11,6 @@ public enum SecurityRulePassTypeEnum {
     NONE(-1, "none")
     ;
 
-    private final Integer code;
+    private final Integer type;
     private final String desc;
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/LicenseController.java

@@ -70,6 +70,8 @@ public class LicenseController {
 		ParamCheckUtil.checkNotNull(req, "req");
 		ParamCheckUtil.checkNotEmpty(req.getName(), "name");
 		ParamCheckUtil.checkNotNull(req.getUserId(), "userId");
+        ParamCheckUtil.checkBytesDesc(req.getUpLimitRate(), "upLimitRate");
+        ParamCheckUtil.checkBytesDesc(req.getDownLimitRate(), "downLimitRate");
 
 		return licenseService.create(req);
 	}
@@ -81,6 +83,8 @@ public class LicenseController {
 		ParamCheckUtil.checkNotNull(req, "req");
 		ParamCheckUtil.checkNotNull(req.getId(), "id");
 		ParamCheckUtil.checkNotEmpty(req.getName(), "name");
+        ParamCheckUtil.checkBytesDesc(req.getUpLimitRate(), "upLimitRate");
+        ParamCheckUtil.checkBytesDesc(req.getDownLimitRate(), "downLimitRate");
 
 		return licenseService.update(req);
 	}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/PortMappingController.java

@@ -43,6 +43,8 @@ public class PortMappingController {
         ParamCheckUtil.checkNotNull(req.getClientPort(), "clientPort");
         ParamCheckUtil.checkNotEmpty(req.getProtocal(), "protocal");
 		ParamCheckUtil.checkMaxLength(req.getDescription(), 50, "描述", "50");
+        ParamCheckUtil.checkBytesDesc(req.getUpLimitRate(), "upLimitRate");
+        ParamCheckUtil.checkBytesDesc(req.getDownLimitRate(), "downLimitRate");
         if (StringUtils.isBlank(req.getClientIp())) {
             // 没传客户端ip，默认为127.0.0.1
             req.setClientIp("127.0.0.1");
@@ -60,6 +62,9 @@ public class PortMappingController {
 		if (null == req.getProxyTimeoutMs()) {
 			req.setProxyTimeoutMs(0L);
 		}
+        if (null == req.getSecurityGroupId()) {
+            req.setSecurityGroupId(0);
+        }
 
 		return portMappingService.create(req);
 	}
@@ -73,6 +78,8 @@ public class PortMappingController {
 		ParamCheckUtil.checkNotNull(req.getClientPort(), "clientPort");
 		ParamCheckUtil.checkNotEmpty(req.getProtocal(), "protocal");
 		ParamCheckUtil.checkMaxLength(req.getDescription(), 50, "描述", "50");
+        ParamCheckUtil.checkBytesDesc(req.getUpLimitRate(), "upLimitRate");
+        ParamCheckUtil.checkBytesDesc(req.getDownLimitRate(), "downLimitRate");
 		if (StringUtils.isBlank(req.getClientIp())) {
 			// 没传客户端ip，默认为127.0.0.1
 			req.setClientIp("127.0.0.1");
@@ -90,6 +97,9 @@ public class PortMappingController {
 		if (null == req.getProxyTimeoutMs()) {
 			req.setProxyTimeoutMs(0L);
 		}
+        if (null == req.getSecurityGroupId()) {
+            req.setSecurityGroupId(0);
+        }
 
         portMappingService.update(req);
 	}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/SecurityController.java

@@ -1,20 +1,15 @@
 package org.dromara.neutrinoproxy.server.controller;
 
-import org.dromara.neutrinoproxy.server.constant.EnableStatusEnum;
-import org.dromara.neutrinoproxy.server.controller.req.system.SecurityGroupCreateReq;
-import org.dromara.neutrinoproxy.server.controller.req.system.SecurityGroupUpdateReq;
-import org.dromara.neutrinoproxy.server.controller.req.system.SecurityRuleCreateReq;
-import org.dromara.neutrinoproxy.server.controller.req.system.SecurityRuleUpdateReq;
-import org.dromara.neutrinoproxy.server.controller.res.system.SecurityGroupRes;
-import org.dromara.neutrinoproxy.server.controller.res.system.SecurityRuleRes;
-import org.dromara.neutrinoproxy.server.dal.entity.SecurityGroupDO;
-import org.dromara.neutrinoproxy.server.dal.entity.SecurityRuleDO;
+import org.dromara.neutrinoproxy.server.base.page.PageInfo;
+import org.dromara.neutrinoproxy.server.base.page.PageQuery;
+import org.dromara.neutrinoproxy.server.controller.req.system.*;
+import org.dromara.neutrinoproxy.server.controller.res.system.*;
 import org.dromara.neutrinoproxy.server.service.PortMappingService;
 import org.dromara.neutrinoproxy.server.service.SecurityGroupService;
+import org.dromara.neutrinoproxy.server.util.ParamCheckUtil;
 import org.noear.solon.annotation.*;
 
 import java.util.List;
-import java.util.stream.Collectors;
 
 @Controller
 @Mapping("/security")
@@ -30,16 +25,26 @@ public class SecurityController {
      * 获取当前用户权限下的安全组
      */
     @Get
-    @Mapping("/group/s")
-    public List<SecurityGroupRes> getGroups() {
-        List<SecurityGroupDO> groupDOList = groupService.queryGroupList();
-        return groupDOList.stream().map(SecurityGroupDO::toRes).collect(Collectors.toList());
+    @Mapping("/group/page")
+    public PageInfo<SecurityGroupListRes> groupPage(PageQuery pageQuery, SecurityGroupListReq req) {
+        ParamCheckUtil.checkNotNull(pageQuery, "pageQuery");
+
+        return groupService.groupPage(pageQuery, req);
     }
 
     @Get
-    @Mapping("/group/getOne")
-    public SecurityGroupRes getGroupOne(Integer groupId) {
-        return groupService.queryGroupOne(groupId).toRes();
+    @Mapping("/group/list")
+    public List<SecurityGroupListRes> groupList() {
+        return groupService.groupList();
+    }
+
+    @Get
+    @Mapping("/group/detail")
+    public SecurityGroupDetailRes groupDetail(SecurityGroupDetailReq req) {
+        ParamCheckUtil.checkNotNull(req, "req");
+        ParamCheckUtil.checkNotNull(req.getId(), "id");
+
+        return groupService.groupDetail(req);
     }
 
     @Post
@@ -61,26 +66,33 @@ public class SecurityController {
     @Post
     @Mapping("/group/delete")
     public void deleteGroup(Integer groupId) {
+        ParamCheckUtil.checkNotNull(groupId, "groupId");
+
         groupService.deleteGroup(groupId);
     }
 
     @Post
-    @Mapping("/group/enable")
-    public void enableGroup(Integer groupId) {
-        groupService.setGroupStatus(groupId, EnableStatusEnum.ENABLE);
-    }
+    @Mapping("/group/update/enable-status")
+    public SecurityGroupUpdateEnableStatueRes updateGroupEnableStatueReq(SecurityGroupUpdateEnableStatueReq req) {
+        ParamCheckUtil.checkNotNull(req, "req");
+        ParamCheckUtil.checkNotNull(req.getId(), "id");
+        ParamCheckUtil.checkNotNull(req.getEnable(), "enable");
 
-    @Post
-    @Mapping("/group/disable")
-    public void disableGroup(Integer groupId) {
-        groupService.setGroupStatus(groupId, EnableStatusEnum.DISABLE);
+        return groupService.updateGroupEnableStatueReq(req);
     }
 
     @Get
-    @Mapping("/rule/s")
-    public List<SecurityRuleRes> getRulesByGroupId(Integer groupId) {
-        List<SecurityRuleDO> ruleDOList = groupService.queryRuleListByGroupId(groupId);
-        return ruleDOList.stream().map(SecurityRuleDO::toRes).collect(Collectors.toList());
+    @Mapping("/rule/page")
+    public PageInfo<SecurityRuleListRes> rulePage(PageQuery pageQuery, SecurityRuleListReq req) {
+        ParamCheckUtil.checkNotNull(pageQuery, "pageQuery");
+
+        return groupService.rulePage(pageQuery, req);
+    }
+
+    @Get
+    @Mapping("/rule/list")
+    public List<SecurityRuleListRes> getRuleListByGroupId(SecurityRuleListReq req) {
+        return groupService.ruleList(req);
     }
 
     @Post
@@ -103,15 +115,13 @@ public class SecurityController {
 
 
     @Post
-    @Mapping("/rule/enable")
-    public void enableRule(Integer ruleId) {
-        groupService.setRuleStatus(ruleId, EnableStatusEnum.ENABLE);
-    }
+    @Mapping("/rule/update/enable-status")
+    public SecurityRuleUpdateEnableStatueRes updateRuleEnableStatueReq(SecurityRuleUpdateEnableStatueReq req) {
+        ParamCheckUtil.checkNotNull(req, "req");
+        ParamCheckUtil.checkNotNull(req.getId(), "id");
+        ParamCheckUtil.checkNotNull(req.getEnable(), "enable");
 
-    @Post
-    @Mapping("/rule/disable")
-    public void disableRule(Integer ruleId) {
-        groupService.setRuleStatus(ruleId, EnableStatusEnum.DISABLE);
+        return groupService.updateRuleEnableStatueReq(req);
     }
 
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/req/proxy/LicenseCreateReq.java

@@ -38,4 +38,12 @@ public class LicenseCreateReq {
 	 * 用户ID
 	 */
 	private Integer userId;
+    /**
+     * 上传限速
+     */
+    private String upLimitRate;
+    /**
+     * 下载限速
+     */
+    private String downLimitRate;
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/req/proxy/LicenseUpdateReq.java

@@ -38,4 +38,12 @@ public class LicenseUpdateReq {
 	 * license名称
 	 */
 	private String name;
+    /**
+     * 上传限速
+     */
+    private String upLimitRate;
+    /**
+     * 下载限速
+     */
+    private String downLimitRate;
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/req/proxy/PortMappingCreateReq.java

@@ -54,6 +54,14 @@ public class PortMappingCreateReq {
 	 * 客户端端口
 	 */
 	private Integer clientPort;
+    /**
+     * 上传限速
+     */
+    private String upLimitRate;
+    /**
+     * 下载限速
+     */
+    private String downLimitRate;
 	/**
 	 * 代理响应数量（响应数据包数量，如果没有拆包则等于数据条数）
 	 */

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/req/proxy/PortMappingUpdateReq.java

@@ -58,6 +58,14 @@ public class PortMappingUpdateReq {
 	 * 客户端端口
 	 */
 	private Integer clientPort;
+    /**
+     * 上传限速
+     */
+    private String upLimitRate;
+    /**
+     * 下载限速
+     */
+    private String downLimitRate;
 	/**
 	 * 代理响应数量（响应数据包数量，如果没有拆包则等于数据条数）
 	 */

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/req/system/SecurityGroupCreateReq.java

@@ -18,6 +18,6 @@ public class SecurityGroupCreateReq {
     /**
      * 通过类型
      */
-    private SecurityRulePassTypeEnum defaultPassType;
+    private Integer defaultPassType;
 
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/req/system/SecurityGroupDetailReq.java

@@ -0,0 +1,12 @@
+package org.dromara.neutrinoproxy.server.controller.req.system;
+
+import lombok.Data;
+
+/**
+ * @author: aoshiguchen
+ * @date: 2023/12/10
+ */
+@Data
+public class SecurityGroupDetailReq {
+    private Integer id;
+}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/req/system/SecurityGroupListReq.java

@@ -0,0 +1,22 @@
+package org.dromara.neutrinoproxy.server.controller.req.system;
+
+import lombok.Data;
+import org.dromara.neutrinoproxy.server.constant.SecurityRulePassTypeEnum;
+
+/**
+ * @author: wen.y
+ * @date: 2023/12/10
+ */
+@Data
+public class SecurityGroupListReq {
+    private String name;
+    /**
+     * 描述
+     */
+    private String description;
+    /**
+     * 通过类型
+     */
+    private Integer defaultPassType;
+    private Integer enable;
+}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/req/system/SecurityGroupUpdateEnableStatueReq.java

@@ -0,0 +1,19 @@
+package org.dromara.neutrinoproxy.server.controller.req.system;
+
+import lombok.Data;
+
+/**
+ * @author: aoshiguchen
+ * @date: 2023/12/10
+ */
+@Data
+public class SecurityGroupUpdateEnableStatueReq {
+    /**
+     * id
+     */
+    private Integer id;
+    /**
+     * 启用状态
+     */
+    private Integer enable;
+}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/req/system/SecurityRuleCreateReq.java

@@ -47,7 +47,7 @@ public class SecurityRuleCreateReq {
      * 放行类型，reject 或 allow
      * {@link SecurityRulePassTypeEnum}
      */
-    private SecurityRulePassTypeEnum passType;
+    private Integer passType;
 
     /**
      * 优先级，数字越小，优先级越高

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/req/system/SecurityRuleListReq.java

@@ -0,0 +1,16 @@
+package org.dromara.neutrinoproxy.server.controller.req.system;
+
+import lombok.Data;
+
+/**
+ * @author: aoshiguchen
+ * @date: 2023/12/10
+ */
+@Data
+public class SecurityRuleListReq {
+    private String groupId;
+    private String name;
+    private String description;
+    private Integer passType;
+    private Integer enable;
+}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/req/system/SecurityRuleUpdateEnableStatueReq.java

@@ -0,0 +1,19 @@
+package org.dromara.neutrinoproxy.server.controller.req.system;
+
+import lombok.Data;
+
+/**
+ * @author: aoshiguchen
+ * @date: 2023/12/10
+ */
+@Data
+public class SecurityRuleUpdateEnableStatueReq {
+    /**
+     * id
+     */
+    private Integer id;
+    /**
+     * 启用状态
+     */
+    private Integer enable;
+}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/req/system/SecurityRuleUpdateReq.java

@@ -41,7 +41,7 @@ public class SecurityRuleUpdateReq {
      * 放行类型，reject 或 allow
      * {@link SecurityRulePassTypeEnum}
      */
-    private SecurityRulePassTypeEnum passType;
+    private Integer passType;
 
     /**
      * 优先级，数字越小，优先级越高

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/res/proxy/LicenseListRes.java

@@ -32,6 +32,14 @@ public class LicenseListRes {
 	 * 用户名
 	 */
 	private String userName;
+    /**
+     * 上传限速
+     */
+    private String upLimitRate;
+    /**
+     * 下载限速
+     */
+    private String downLimitRate;
 	/**
 	 * 是否在线
 	 * {@link OnlineStatusEnum}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/res/proxy/PortMappingListRes.java

@@ -75,6 +75,14 @@ public class PortMappingListRes {
 	 * 客户端端口
 	 */
 	private Integer clientPort;
+    /**
+     * 上传限速
+     */
+    private String upLimitRate;
+    /**
+     * 下载限速
+     */
+    private String downLimitRate;
 	/**
 	 * 客户端端口
 	 */

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/res/system/SecurityGroupDetailRes.java

@@ -5,11 +5,9 @@ import lombok.experimental.Accessors;
 import org.dromara.neutrinoproxy.server.constant.EnableStatusEnum;
 import org.dromara.neutrinoproxy.server.constant.SecurityRulePassTypeEnum;
 
-import java.util.Date;
-
 @Data
 @Accessors(chain = true)
-public class SecurityGroupRes {
+public class SecurityGroupDetailRes {
 
     private Integer id;
 
@@ -27,13 +25,13 @@ public class SecurityGroupRes {
      * 启用状态
      * {@link EnableStatusEnum}
      */
-    private String enable;
+    private Integer enable;
 
     /**
      * 默认放行类型
      * {@link SecurityRulePassTypeEnum}
      */
-    private String defaultPassType;
+    private Integer defaultPassType;
 
     /**
      * 创建时间

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/res/system/SecurityGroupListRes.java

@@ -0,0 +1,49 @@
+package org.dromara.neutrinoproxy.server.controller.res.system;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+import org.dromara.neutrinoproxy.server.constant.EnableStatusEnum;
+import org.dromara.neutrinoproxy.server.constant.SecurityRulePassTypeEnum;
+
+import java.util.Date;
+
+@Data
+@Accessors(chain = true)
+public class SecurityGroupListRes {
+
+    private Integer id;
+
+    /**
+     * 组名
+     */
+    private String name;
+
+    /**
+     * 描述
+     */
+    private String description;
+
+    /**
+     * 启用状态
+     * {@link EnableStatusEnum}
+     */
+    private Integer enable;
+
+    /**
+     * 默认放行类型
+     * {@link SecurityRulePassTypeEnum}
+     */
+    private Integer defaultPassType;
+
+    /**
+     * 创建时间
+     */
+    private Date createTime;
+    /**
+     * 更新时间
+     */
+    private Date updateTime;
+
+
+
+}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/res/system/SecurityGroupUpdateEnableStatueRes.java

@@ -0,0 +1,12 @@
+package org.dromara.neutrinoproxy.server.controller.res.system;
+
+import lombok.Data;
+
+/**
+ * @author: aoshiguchen
+ * @date: 2023/12/10
+ */
+@Data
+public class SecurityGroupUpdateEnableStatueRes {
+
+}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/res/system/SecurityRuleListRes.java

@@ -3,7 +3,6 @@ package org.dromara.neutrinoproxy.server.controller.res.system;
 import lombok.Data;
 import lombok.ToString;
 import lombok.experimental.Accessors;
-import org.dromara.neutrinoproxy.server.constant.EnableStatusEnum;
 import org.dromara.neutrinoproxy.server.constant.SecurityRulePassTypeEnum;
 
 import java.util.Date;
@@ -11,7 +10,7 @@ import java.util.Date;
 @Data
 @ToString
 @Accessors(chain = true)
-public class SecurityRuleRes {
+public class SecurityRuleListRes {
 
     private Integer id;
 
@@ -44,7 +43,7 @@ public class SecurityRuleRes {
      * 放行类型，reject 或 allow
      * {@link SecurityRulePassTypeEnum}
      */
-    private String passType;
+    private Integer passType;
 
     /**
      * 优先级，数字越小，优先级越高
@@ -54,15 +53,15 @@ public class SecurityRuleRes {
     /**
      * 启用状态
      */
-    private String enable;
+    private Integer enable;
 
     /**
      * 创建时间
      */
-    private String createTime;
+    private Date createTime;
     /**
      * 更新时间
      */
-    private String updateTime;
+    private Date updateTime;
 
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/controller/res/system/SecurityRuleUpdateEnableStatueRes.java

@@ -0,0 +1,8 @@
+package org.dromara.neutrinoproxy.server.controller.res.system;
+
+/**
+ * @author: aoshiguchen
+ * @date: 2023/12/10
+ */
+public class SecurityRuleUpdateEnableStatueRes {
+}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/dal/LicenseMapper.java

@@ -89,14 +89,6 @@ public interface LicenseMapper extends BaseMapper<LicenseDO> {
         return this.selectById(id);
     }
 
-    default void update(Integer id, String name, Date updateTime) {
-        this.update(null, new LambdaUpdateWrapper<LicenseDO>()
-                .eq(LicenseDO::getId, id)
-                .set(LicenseDO::getName, name)
-                .set(LicenseDO::getUpdateTime, updateTime)
-        );
-    }
-
     default List<LicenseDO> findByIds(Set<Integer> ids) {
         return selectBatchIds(ids);
     }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/dal/SecurityGroupMapper.java

@@ -1,7 +1,25 @@
 package org.dromara.neutrinoproxy.server.dal;
 
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import org.apache.ibatis.annotations.Param;
+import org.dromara.neutrinoproxy.server.controller.req.proxy.PortMappingListReq;
+import org.dromara.neutrinoproxy.server.controller.req.system.SecurityGroupListReq;
+import org.dromara.neutrinoproxy.server.dal.entity.PortMappingDO;
 import org.dromara.neutrinoproxy.server.dal.entity.SecurityGroupDO;
 
+import java.util.Date;
+import java.util.List;
+
 public interface SecurityGroupMapper extends BaseMapper<SecurityGroupDO> {
+    List<SecurityGroupDO> selectByCondition(IPage<SecurityGroupDO> page, @Param("req") SecurityGroupListReq req);
+
+    default void updateEnableStatus(Integer id, Integer enable, Date updateTime) {
+        this.update(null, new LambdaUpdateWrapper<SecurityGroupDO>()
+            .eq(SecurityGroupDO::getId, id)
+            .set(SecurityGroupDO::getEnable, enable)
+            .set(SecurityGroupDO::getUpdateTime, updateTime)
+        );
+    }
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/dal/SecurityRuleMapper.java

@@ -1,7 +1,25 @@
 package org.dromara.neutrinoproxy.server.dal;
 
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import org.apache.ibatis.annotations.Param;
+import org.dromara.neutrinoproxy.server.controller.req.system.SecurityGroupListReq;
+import org.dromara.neutrinoproxy.server.controller.req.system.SecurityRuleListReq;
+import org.dromara.neutrinoproxy.server.dal.entity.SecurityGroupDO;
 import org.dromara.neutrinoproxy.server.dal.entity.SecurityRuleDO;
 
+import java.util.Date;
+import java.util.List;
+
 public interface SecurityRuleMapper extends BaseMapper<SecurityRuleDO> {
+    List<SecurityRuleDO> selectByCondition(IPage<SecurityRuleDO> page, @Param("req") SecurityRuleListReq req);
+
+    default void updateEnableStatus(Integer id, Integer enable, Date updateTime) {
+        this.update(null, new LambdaUpdateWrapper<SecurityRuleDO>()
+                .eq(SecurityRuleDO::getId, id)
+                .set(SecurityRuleDO::getEnable, enable)
+                .set(SecurityRuleDO::getUpdateTime, updateTime)
+        );
+    }
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/dal/entity/LicenseDO.java

@@ -21,6 +21,7 @@
  */
 package org.dromara.neutrinoproxy.server.dal.entity;
 
+import cn.hutool.core.bean.BeanUtil;
 import com.baomidou.mybatisplus.annotation.IdType;
 import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
@@ -59,6 +60,14 @@ public class LicenseDO {
 	 * 用户ID
 	 */
 	private Integer userId;
+    /**
+     * 上传限速
+     */
+    private String upLimitRate;
+    /**
+     * 下载限速
+     */
+    private String downLimitRate;
 	/**
 	 * 是否在线
 	 * {@link OnlineStatusEnum}
@@ -80,14 +89,7 @@ public class LicenseDO {
 
     public LicenseListRes toRes() {
         LicenseListRes res = new LicenseListRes();
-        res.setId(id);
-        res.setName(name);
-        res.setKey(key);
-        res.setUserId(userId);
-        res.setIsOnline(isOnline);
-        res.setEnable(enable);
-        res.setCreateTime(createTime);
-        res.setUpdateTime(updateTime);
+        BeanUtil.copyProperties(this, res);
         return res;
     }
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/dal/entity/PortMappingDO.java

@@ -70,6 +70,14 @@ public class PortMappingDO {
 	 * 客户端端口
 	 */
 	private Integer clientPort;
+    /**
+     * 上传限速
+     */
+    private String upLimitRate;
+    /**
+     * 下载限速
+     */
+    private String downLimitRate;
 	/**
 	 * 描述
 	 */

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/dal/entity/SecurityGroupDO.java

@@ -11,7 +11,8 @@ import lombok.ToString;
 import lombok.experimental.Accessors;
 import org.dromara.neutrinoproxy.server.constant.EnableStatusEnum;
 import org.dromara.neutrinoproxy.server.constant.SecurityRulePassTypeEnum;
-import org.dromara.neutrinoproxy.server.controller.res.system.SecurityGroupRes;
+import org.dromara.neutrinoproxy.server.controller.res.system.SecurityGroupDetailRes;
+import org.dromara.neutrinoproxy.server.controller.res.system.SecurityGroupListRes;
 
 import java.util.Date;
 
@@ -38,18 +39,17 @@ public class SecurityGroupDO {
      * 用户id
      */
     private Integer userId;
-
     /**
      * 启用状态
      * {@link EnableStatusEnum}
      */
-    private EnableStatusEnum enable;
+    private Integer enable;
 
     /**
      * 默认放行类型
      * {@link SecurityRulePassTypeEnum}
      */
-    private SecurityRulePassTypeEnum defaultPassType;
+    private Integer defaultPassType;
 
     /**
      * 创建时间
@@ -60,15 +60,15 @@ public class SecurityGroupDO {
      */
     private Date updateTime;
 
-    public SecurityGroupRes toRes() {
-        SecurityGroupRes res = new SecurityGroupRes();
+    public SecurityGroupListRes toListRes() {
+        SecurityGroupListRes res = new SecurityGroupListRes();
         BeanUtil.copyProperties(this, res);
-        res.setEnable(enable.getDesc())
-            .setDefaultPassType(defaultPassType.getDesc())
-            .setCreateTime(DateUtil.format(this.getCreateTime(), DatePattern.NORM_DATETIME_FORMAT))
-            .setUpdateTime(DateUtil.format(this.getUpdateTime(), DatePattern.NORM_DATETIME_FORMAT));
         return res;
     }
 
-
+    public SecurityGroupDetailRes toDetailRes() {
+        SecurityGroupDetailRes res = new SecurityGroupDetailRes();
+        BeanUtil.copyProperties(this, res);
+        return res;
+    }
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/dal/entity/SecurityRuleDO.java

@@ -1,8 +1,6 @@
 package org.dromara.neutrinoproxy.server.dal.entity;
 
 import cn.hutool.core.bean.BeanUtil;
-import cn.hutool.core.date.DatePattern;
-import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.net.Ipv4Util;
 import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.annotation.IdType;
@@ -13,7 +11,7 @@ import lombok.ToString;
 import lombok.experimental.Accessors;
 import org.dromara.neutrinoproxy.server.constant.EnableStatusEnum;
 import org.dromara.neutrinoproxy.server.constant.SecurityRulePassTypeEnum;
-import org.dromara.neutrinoproxy.server.controller.res.system.SecurityRuleRes;
+import org.dromara.neutrinoproxy.server.controller.res.system.SecurityRuleListRes;
 
 import java.util.Date;
 
@@ -55,7 +53,7 @@ public class SecurityRuleDO {
      * 放行类型，reject 或 allow
      * {@link SecurityRulePassTypeEnum}
      */
-    private SecurityRulePassTypeEnum passType;
+    private Integer passType;
 
     /**
      * 优先级，数字越小，优先级越高
@@ -71,7 +69,7 @@ public class SecurityRuleDO {
      * 启用状态
      * {@link EnableStatusEnum}
      */
-    private EnableStatusEnum enable;
+    private Integer enable;
     /**
      * 创建时间
      */
@@ -113,7 +111,7 @@ public class SecurityRuleDO {
             // 单个ip,ipv6在此步已处理，后面不需要额外判断ipv6的情况
             if (rule.matches("(\\d+\\.){3}\\d+") || isIpv6) {
                 if (rule.equalsIgnoreCase(ip)) {
-                    return passType == SecurityRulePassTypeEnum.ALLOW ? SecurityRulePassTypeEnum.ALLOW : SecurityRulePassTypeEnum.DENY;
+                    return SecurityRulePassTypeEnum.ALLOW.getType().equals(passType) ? SecurityRulePassTypeEnum.ALLOW : SecurityRulePassTypeEnum.DENY;
                 }
             }
 
@@ -121,7 +119,7 @@ public class SecurityRuleDO {
             if (rule.matches("(\\d+\\.){3}\\d+-(\\d+\\.){3}\\d+")) {
                 String[] ipRange = rule.split("-");
                 if (ipRange[0].compareTo(ip) <= 0 && ip.compareTo(ipRange[1]) <= 0) {
-                    return passType == SecurityRulePassTypeEnum.ALLOW ? SecurityRulePassTypeEnum.ALLOW : SecurityRulePassTypeEnum.DENY;
+                    return SecurityRulePassTypeEnum.ALLOW.getType().equals(passType) ? SecurityRulePassTypeEnum.ALLOW : SecurityRulePassTypeEnum.DENY;
                 }
             }
 
@@ -131,12 +129,12 @@ public class SecurityRuleDO {
                 Long beginIp = Ipv4Util.getBeginIpLong(netIp[0], Integer.parseInt(netIp[1]));
                 Long endIp = Ipv4Util.getEndIpLong(netIp[0], Integer.parseInt(netIp[1]));
                 if (beginIp <= ipLong && ipLong <= endIp) {
-                    return passType == SecurityRulePassTypeEnum.ALLOW ? SecurityRulePassTypeEnum.ALLOW : SecurityRulePassTypeEnum.DENY;
+                    return SecurityRulePassTypeEnum.ALLOW.getType().equals(passType) ? SecurityRulePassTypeEnum.ALLOW : SecurityRulePassTypeEnum.DENY;
                 }
             }
 
             if (rule.equalsIgnoreCase("ALL") || rule.equals("0.0.0.0") || rule.equals("0.0.0.0/0")) {
-                return passType == SecurityRulePassTypeEnum.ALLOW ? SecurityRulePassTypeEnum.ALLOW : SecurityRulePassTypeEnum.DENY;
+                return SecurityRulePassTypeEnum.ALLOW.getType().equals(passType) ? SecurityRulePassTypeEnum.ALLOW : SecurityRulePassTypeEnum.DENY;
             }
 
         }
@@ -145,14 +143,9 @@ public class SecurityRuleDO {
         return SecurityRulePassTypeEnum.NONE;
     }
 
-    public SecurityRuleRes toRes() {
-        SecurityRuleRes res = new SecurityRuleRes();
+    public SecurityRuleListRes toListRes() {
+        SecurityRuleListRes res = new SecurityRuleListRes();
         BeanUtil.copyProperties(this, res);
-        res.setPassType(this.passType.getDesc())
-            .setEnable(this.getEnable().getDesc())
-            .setCreateTime(DateUtil.format(this.getCreateTime(), DatePattern.NORM_DATETIME_FORMAT))
-            .setUpdateTime(DateUtil.format(this.getUpdateTime(), DatePattern.NORM_DATETIME_FORMAT))
-        ;
         return res;
     }
 

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/proxy/core/TcpVisitorChannelHandler.java

@@ -9,15 +9,11 @@ import io.netty.channel.SimpleChannelInboundHandler;
 import lombok.extern.slf4j.Slf4j;
 import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
-import org.dromara.neutrinoproxy.core.util.IpUtil;
 import org.dromara.neutrinoproxy.server.constant.NetworkProtocolEnum;
 import org.dromara.neutrinoproxy.server.proxy.domain.VisitorChannelAttachInfo;
 import org.dromara.neutrinoproxy.server.service.FlowReportService;
-import org.dromara.neutrinoproxy.server.service.PortMappingService;
-import org.dromara.neutrinoproxy.server.service.SecurityGroupService;
 import org.dromara.neutrinoproxy.server.util.ProxyUtil;
 import org.noear.solon.Solon;
-import org.noear.solon.annotation.Inject;
 
 import java.net.InetSocketAddress;
 
@@ -29,10 +25,6 @@ import java.net.InetSocketAddress;
 @Slf4j
 public class TcpVisitorChannelHandler extends SimpleChannelInboundHandler<ByteBuf> {
 
-    private final SecurityGroupService securityGroupService = Solon.context().getBean(SecurityGroupService.class);
-
-    private final PortMappingService portMappingService = Solon.context().getBean(PortMappingService.class);
-
     @Override
     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
         // 当出现异常就关闭连接
@@ -51,21 +43,13 @@ public class TcpVisitorChannelHandler extends SimpleChannelInboundHandler<ByteBu
             ctx.channel().close();
             return;
         }
-
-        // 判断IP是否在该端口绑定的安全组允许的规则内
-        InetSocketAddress sa = (InetSocketAddress) visitorChannel.localAddress();
-        if (!securityGroupService.judgeAllow(IpUtil.getRemoteIp(ctx), portMappingService.getSecurityGroupIdByMappingPort(sa.getPort()))) {
-            // 不在安全组规则放行范围内
-            ctx.channel().close();
-            return;
-        }
+        byte[] bytes = new byte[buf.readableBytes()];
+        buf.readBytes(bytes);
 
         // 代理通道可写，则设置访问通道可读。代理通道不可写，则设置访问通道不可读
         visitorChannel.config().setAutoRead(proxyChannel.isWritable());
 
         // 转发代理数据
-        byte[] bytes = new byte[buf.readableBytes()];
-        buf.readBytes(bytes);
         String visitorId = ProxyUtil.getVisitorIdByChannel(visitorChannel);
         proxyChannel.writeAndFlush(ProxyMessage.buildTransferMessage(visitorId, bytes));
 
@@ -79,13 +63,6 @@ public class TcpVisitorChannelHandler extends SimpleChannelInboundHandler<ByteBu
         Channel visitorChannel = ctx.channel();
         InetSocketAddress sa = (InetSocketAddress) visitorChannel.localAddress();
 
-        // 判断IP是否在该端口绑定的安全组允许的规则内
-        if (!securityGroupService.judgeAllow(IpUtil.getRemoteIp(ctx), portMappingService.getSecurityGroupIdByMappingPort(sa.getPort()))) {
-            // 不在安全组规则放行范围内
-            ctx.channel().close();
-            return;
-        }
-
         Channel cmdChannel = ProxyUtil.getCmdChannelByServerPort(sa.getPort());
         if (null == cmdChannel) {
             // 该端口还没有代理客户端

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/proxy/core/UdpVisitorChannelHandler.java

@@ -7,22 +7,16 @@ import io.netty.channel.ChannelOption;
 import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.channel.socket.DatagramPacket;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
 import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
-import org.dromara.neutrinoproxy.core.util.IpUtil;
 import org.dromara.neutrinoproxy.server.constant.NetworkProtocolEnum;
 import org.dromara.neutrinoproxy.server.proxy.domain.ProxyAttachment;
 import org.dromara.neutrinoproxy.server.proxy.domain.VisitorChannelAttachInfo;
 import org.dromara.neutrinoproxy.server.service.FlowReportService;
-import org.dromara.neutrinoproxy.server.service.PortMappingService;
-import org.dromara.neutrinoproxy.server.service.SecurityGroupService;
 import org.dromara.neutrinoproxy.server.util.ProxyUtil;
 import org.noear.solon.Solon;
-import org.noear.solon.annotation.Inject;
 
 import java.net.InetSocketAddress;
-import java.nio.charset.StandardCharsets;
 
 /**
  * @author: aoshiguchen
@@ -31,21 +25,11 @@ import java.nio.charset.StandardCharsets;
 @Slf4j
 public class UdpVisitorChannelHandler extends SimpleChannelInboundHandler<DatagramPacket> {
 
-    private final SecurityGroupService securityGroupService = Solon.context().getBean(SecurityGroupService.class);
-
-    private final PortMappingService portMappingService = Solon.context().getBean(PortMappingService.class);
-
     @Override
     protected void channelRead0(ChannelHandlerContext ctx, DatagramPacket datagramPacket) throws Exception {
-        log.debug("chid>>>{}", ctx.channel().id().asLongText());
         Channel visitorChannel = ctx.channel();
         InetSocketAddress sa = (InetSocketAddress) visitorChannel.localAddress();
 
-        // 判断IP是否在该端口绑定的安全组允许的规则内
-        if (!securityGroupService.judgeAllow(datagramPacket.sender().getAddress().getHostAddress(), portMappingService.getSecurityGroupIdByMappingPort(sa.getPort()))) {
-            return;
-        }
-
         byte[] bytes = new byte[datagramPacket.content().readableBytes()];
         datagramPacket.content().readBytes(bytes);
         datagramPacket.content().resetReaderIndex();
@@ -81,12 +65,6 @@ public class UdpVisitorChannelHandler extends SimpleChannelInboundHandler<Datagr
             Solon.context().getBean(FlowReportService.class).addWriteByte(visitorChannelAttachInfo.getLicenseId(), bytes.length);
         });
 
-//        String visitorId = ProxyUtil.getVisitorIdByChannel(ctx.channel());
-//        if (StringUtils.isNotBlank(visitorId)) {
-//            // UDP代理隧道已就绪，直接转发
-//            proxyAttachment.execute();
-//            return;
-//        }
         Channel proxyChannel = ctx.channel().attr(Constants.NEXT_CHANNEL).get();
         if (null != proxyChannel && proxyChannel.isActive()) {
             // UDP代理隧道已就绪，直接转发

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/proxy/enhance/HttpProxy.java

@@ -11,6 +11,8 @@ import lombok.extern.slf4j.Slf4j;
 import org.dromara.neutrinoproxy.server.base.proxy.ProxyConfig;
 import org.dromara.neutrinoproxy.server.proxy.core.BytesMetricsHandler;
 import org.dromara.neutrinoproxy.server.proxy.core.ProxyTunnelServer;
+import org.dromara.neutrinoproxy.server.proxy.security.HttpVisitorSecurityChannelHandler;
+import org.dromara.neutrinoproxy.server.proxy.security.VisitorFlowLimiterChannelHandler;
 import org.noear.solon.annotation.Component;
 import org.noear.solon.annotation.Inject;
 import org.noear.solon.core.event.AppLoadEndEvent;
@@ -46,7 +48,9 @@ public class HttpProxy implements EventListener<AppLoadEndEvent> {
                                 ch.pipeline().addFirst(new LoggingHandler(HttpProxy.class));
                             }
                             ch.pipeline().addFirst(new BytesMetricsHandler());
-                            ch.pipeline().addLast(new HttpVisitorChannelHandler(proxyConfig.getServer().getTcp().getDomainName()));
+                            ch.pipeline().addLast(new HttpVisitorSecurityChannelHandler(proxyConfig.getServer().getTcp().getDomainName()));
+                            ch.pipeline().addLast("flowLimiter",new VisitorFlowLimiterChannelHandler());
+                            ch.pipeline().addLast(new HttpVisitorChannelHandler());
                         }
                     });
             bootstrap.bind("0.0.0.0", proxyConfig.getServer().getTcp().getHttpProxyPort()).sync();

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/proxy/enhance/HttpVisitorChannelHandler.java

@@ -1,6 +1,5 @@
 package org.dromara.neutrinoproxy.server.proxy.enhance;
 
-import cn.hutool.core.util.StrUtil;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
@@ -10,16 +9,12 @@ import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.dromara.neutrinoproxy.core.Constants;
 import org.dromara.neutrinoproxy.core.ProxyMessage;
-import org.dromara.neutrinoproxy.core.util.IpUtil;
 import org.dromara.neutrinoproxy.server.constant.NetworkProtocolEnum;
 import org.dromara.neutrinoproxy.server.proxy.domain.ProxyAttachment;
 import org.dromara.neutrinoproxy.server.proxy.domain.VisitorChannelAttachInfo;
 import org.dromara.neutrinoproxy.server.service.FlowReportService;
-import org.dromara.neutrinoproxy.server.service.PortMappingService;
-import org.dromara.neutrinoproxy.server.service.SecurityGroupService;
 import org.dromara.neutrinoproxy.server.util.ProxyUtil;
 import org.noear.solon.Solon;
-import org.noear.solon.annotation.Inject;
 
 import java.net.InetSocketAddress;
 
@@ -30,26 +25,8 @@ import java.net.InetSocketAddress;
 @Slf4j
 public class HttpVisitorChannelHandler extends SimpleChannelInboundHandler<ByteBuf> {
 
-    private final SecurityGroupService securityGroupService = Solon.context().getBean(SecurityGroupService.class);
-
-    private final PortMappingService portMappingService = Solon.context().getBean(PortMappingService.class);
-
-    /**
-     * 域名
-     */
-    private String domainName;
-
-    public HttpVisitorChannelHandler(String domainName) {
-        this.domainName = domainName;
-    }
-
     @Override
     protected void channelRead0(ChannelHandlerContext ctx, ByteBuf byteBuf) throws Exception {
-        if (StrUtil.isBlank(domainName)) {
-            ctx.channel().close();
-            return;
-        }
-
         byte[] bytes = new byte[byteBuf.readableBytes()];
         byteBuf.readBytes(bytes);
         byteBuf.resetReaderIndex();
@@ -77,33 +54,9 @@ public class HttpVisitorChannelHandler extends SimpleChannelInboundHandler<ByteB
         // 用户连接到代理服务器时，设置用户连接不可读，等待代理后端服务器连接成功后再改变为可读状态
         ctx.channel().config().setOption(ChannelOption.AUTO_READ, false);
 
-        String host = getHost(bytes);
-        log.debug("HttpProxy host: {}", host);
-        if (StringUtils.isBlank(host)) {
-            ctx.channel().close();
-            return;
-        }
-        if (!host.endsWith(domainName)) {
-            ctx.channel().close();
-            return;
-        }
-        int index = host.lastIndexOf("." + domainName);
-        String subdomain = host.substring(0, index);
 
         // 根据域名拿到绑定的映射对应的cmdChannel
-        Integer serverPort = ProxyUtil.getServerPortBySubdomain(subdomain);
-        if (null == serverPort) {
-            ctx.channel().close();
-            return;
-        }
-
-        // 判断IP是否在该端口绑定的安全组允许的规则内
-        if (!securityGroupService.judgeAllow(IpUtil.getRemoteIp(ctx), portMappingService.getSecurityGroupIdByMappingPort(serverPort))) {
-            // 不在安全组规则放行范围内
-            ctx.channel().close();
-            return;
-        }
-
+        Integer serverPort = ctx.channel().attr(Constants.SERVER_PORT).get();
         Channel cmdChannel = ProxyUtil.getCmdChannelByServerPort(serverPort);
         if (null == cmdChannel) {
             ctx.channel().close();
@@ -167,23 +120,15 @@ public class HttpVisitorChannelHandler extends SimpleChannelInboundHandler<ByteB
         ctx.close();
     }
 
-    private String getHost(byte[] buf) {
-        String req = new String(buf);
-        String[] lines = req.split("\r\n");
-        String firstLine = lines[0];
-        if (!(firstLine.endsWith("HTTP/1.1") || firstLine.endsWith("HTTP/1.0"))) {
-            return null;
+    @Override
+    public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
+
+        // 通知代理客户端
+        Channel visitorChannel = ctx.channel();
+        Channel proxyChannel = visitorChannel.attr(Constants.NEXT_CHANNEL).get();
+        if (null != proxyChannel) {
+            proxyChannel.config().setOption(ChannelOption.AUTO_READ, visitorChannel.isWritable());
         }
-        for (int i = 1; i < lines.length; i++) {
-            String line = lines[i];
-            if (!line.startsWith("Host: ")) {
-                continue;
-            }
-            // 域名
-            String domain = line.substring(6);
-            // 去掉域名后面的端口号
-            return domain.replaceAll(":.*", "");
-        }
-        return null;
+        super.channelWritabilityChanged(ctx);
     }
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/proxy/enhance/HttpsProxy.java

@@ -14,6 +14,8 @@ import org.dromara.neutrinoproxy.core.util.FileUtil;
 import org.dromara.neutrinoproxy.server.base.proxy.ProxyConfig;
 import org.dromara.neutrinoproxy.server.proxy.core.BytesMetricsHandler;
 import org.dromara.neutrinoproxy.server.proxy.core.ProxyTunnelServer;
+import org.dromara.neutrinoproxy.server.proxy.security.HttpVisitorSecurityChannelHandler;
+import org.dromara.neutrinoproxy.server.proxy.security.VisitorFlowLimiterChannelHandler;
 import org.noear.solon.annotation.Component;
 import org.noear.solon.annotation.Inject;
 import org.noear.solon.core.event.AppLoadEndEvent;
@@ -55,7 +57,9 @@ public class HttpsProxy implements EventListener<AppLoadEndEvent> {
                             }
                             ch.pipeline().addLast(createSslHandler());
                             ch.pipeline().addFirst(new BytesMetricsHandler());
-                            ch.pipeline().addLast(new HttpVisitorChannelHandler(proxyConfig.getServer().getTcp().getDomainName()));
+                            ch.pipeline().addLast(new HttpVisitorSecurityChannelHandler(proxyConfig.getServer().getTcp().getDomainName()));
+                            ch.pipeline().addLast("flowLimiter",new VisitorFlowLimiterChannelHandler());
+                            ch.pipeline().addLast(new HttpVisitorChannelHandler());
                         }
                     });
             bootstrap.bind("0.0.0.0", proxyConfig.getServer().getTcp().getHttpsProxyPort()).sync();

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/proxy/handler/ProxyMessageAuthHandler.java

@@ -90,7 +90,7 @@ public class ProxyMessageAuthHandler implements ProxyMessageHandler {
 
 		if (StrUtil.isEmpty(licenseKey)) {
 			log.warn("[client connection] license cannot empty info:{} ", info);
-			ctx.channel().writeAndFlush(ProxyMessage.buildAuthResultMessage(ExceptionEnum.AUTH_FAILED.getCode(), "license不能为空!", licenseKey));
+			ctx.channel().writeAndFlush(ProxyMessage.buildAuthResultMessage(ExceptionEnum.AUTH_FAILED.getCode(), "license cannot be empty!", licenseKey));
 			ctx.channel().close();
 			clientConnectRecordService.add(new ClientConnectRecordDO()
 					.setIp(ip)
@@ -105,7 +105,7 @@ public class ProxyMessageAuthHandler implements ProxyMessageHandler {
 		LicenseDO licenseDO = licenseService.findByKey(licenseKey);
 		if (null == licenseDO) {
 			log.warn("[client connection] license notfound info:{} ", info);
-			ctx.channel().writeAndFlush(ProxyMessage.buildAuthResultMessage(ExceptionEnum.AUTH_FAILED.getCode(), "license不存在!", licenseKey));
+			ctx.channel().writeAndFlush(ProxyMessage.buildAuthResultMessage(ExceptionEnum.AUTH_FAILED.getCode(), "license not found!", licenseKey));
 			ctx.channel().close();
 			clientConnectRecordService.add(new ClientConnectRecordDO()
 					.setIp(ip)

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/proxy/handler/ProxyMessageConnectHandler.java

@@ -82,7 +82,8 @@ public class ProxyMessageConnectHandler implements ProxyMessageHandler {
 		ctx.channel().attr(Constants.LICENSE_ID).set(licenseDO.getId());
 		ctx.channel().attr(Constants.NEXT_CHANNEL).set(visitorChannel);
 		visitorChannel.attr(Constants.NEXT_CHANNEL).set(ctx.channel());
-		// 代理客户端与后端服务器连接成功，修改用户连接为可读状态
+        visitorChannel.attr(Constants.LICENSE_ID).set(licenseDO.getId());
+        // 代理客户端与后端服务器连接成功，修改用户连接为可读状态
 		visitorChannel.config().setOption(ChannelOption.AUTO_READ, true);
 
 		// 获取代理附加对象

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/proxy/security/HttpVisitorSecurityChannelHandler.java

@@ -0,0 +1,92 @@
+package org.dromara.neutrinoproxy.server.proxy.security;
+
+import cn.hutool.core.util.StrUtil;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.dromara.neutrinoproxy.core.Constants;
+import org.dromara.neutrinoproxy.core.util.HttpUtil;
+import org.dromara.neutrinoproxy.core.util.IpUtil;
+import org.dromara.neutrinoproxy.server.service.PortMappingService;
+import org.dromara.neutrinoproxy.server.service.SecurityGroupService;
+import org.dromara.neutrinoproxy.server.util.ProxyUtil;
+import org.noear.solon.Solon;
+
+/**
+ * @author: aoshiguchen
+ * @date: 2023/12/14
+ */
+@Slf4j
+public class HttpVisitorSecurityChannelHandler extends ChannelInboundHandlerAdapter {
+    private final SecurityGroupService securityGroupService = Solon.context().getBean(SecurityGroupService.class);
+    private final PortMappingService portMappingService = Solon.context().getBean(PortMappingService.class);
+    /**
+     * 域名
+     */
+    private String domainName;
+
+    public HttpVisitorSecurityChannelHandler(String domainName) {
+        this.domainName = domainName;
+    }
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        // 未配置域名则不支持通过域名访问
+        if (StrUtil.isBlank(domainName)) {
+            ctx.channel().close();
+            return;
+        }
+
+        ByteBuf buf = (ByteBuf) msg;
+
+        Integer serverPort = ctx.channel().attr(Constants.SERVER_PORT).get();
+        if (null == serverPort) {
+            // 获取Host请求头
+            byte[] bytes = new byte[buf.readableBytes()];
+            buf.readBytes(bytes);
+            String httpContent = new String(bytes);
+            String host = HttpUtil.getHostIgnorePort(httpContent);
+
+            log.debug("HttpProxy host: {}", host);
+            if (StringUtils.isBlank(host)) {
+                ctx.channel().close();
+                return;
+            }
+
+            // 根据Host匹配端口映射
+            if (!host.endsWith(domainName)) {
+                ctx.channel().close();
+                return;
+            }
+            int index = host.lastIndexOf("." + domainName);
+            String subdomain = host.substring(0, index);
+
+            // 根据域名拿到绑定的映射对应的cmdChannel
+            serverPort = ProxyUtil.getServerPortBySubdomain(subdomain);
+            if (null == serverPort) {
+                ctx.channel().close();
+                return;
+            }
+
+            // 判断IP是否在该端口绑定的安全组允许的规则内
+            String ip = IpUtil.getRealRemoteIp(httpContent);
+            if (ip == null) {
+                ip = IpUtil.getRemoteIp(ctx);
+            }
+            if (!securityGroupService.judgeAllow(ip, portMappingService.getSecurityGroupIdByMappingPort(serverPort))) {
+                // 不在安全组规则放行范围内
+                ctx.channel().close();
+                return;
+            }
+
+            ctx.channel().attr(Constants.REAL_REMOTE_IP).set(ip);
+            ctx.channel().attr(Constants.SERVER_PORT).set(serverPort);
+        }
+
+        // 继续传播
+        buf.resetReaderIndex();
+        ctx.fireChannelRead(buf);
+    }
+
+}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/proxy/security/TcpVisitorSecurityChannelHandler.java

@@ -0,0 +1,68 @@
+package org.dromara.neutrinoproxy.server.proxy.security;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.dromara.neutrinoproxy.core.Constants;
+import org.dromara.neutrinoproxy.core.util.IpUtil;
+import org.dromara.neutrinoproxy.server.service.PortMappingService;
+import org.dromara.neutrinoproxy.server.service.SecurityGroupService;
+import org.noear.solon.Solon;
+
+import java.net.InetSocketAddress;
+
+/**
+ * @author: aoshiguchen
+ * @date: 2023/12/14
+ */
+@Slf4j
+public class TcpVisitorSecurityChannelHandler extends ChannelInboundHandlerAdapter {
+    private final SecurityGroupService securityGroupService = Solon.context().getBean(SecurityGroupService.class);
+    private final PortMappingService portMappingService = Solon.context().getBean(PortMappingService.class);
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        Channel visitorChannel = ctx.channel();
+
+        ByteBuf buf = (ByteBuf) msg;
+        byte[] bytes = new byte[buf.readableBytes()];
+        buf.readBytes(bytes);
+
+        // 判断IP是否在该端口绑定的安全组允许的规则内
+        String ip = IpUtil.getRealRemoteIp(new String(bytes));
+        if (StringUtils.isEmpty(ip)) {
+            ip = IpUtil.getRemoteIp(ctx);
+        }
+        InetSocketAddress sa = (InetSocketAddress) visitorChannel.localAddress();
+        if (!securityGroupService.judgeAllow(ip, portMappingService.getSecurityGroupIdByMappingPort(sa.getPort()))) {
+            // 不在安全组规则放行范围内
+            ctx.channel().close();
+            return;
+        }
+
+        // 继续传播
+        ctx.channel().attr(Constants.SERVER_PORT).set(sa.getPort());
+        buf.resetReaderIndex();
+        ctx.fireChannelRead(buf);
+    }
+
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) throws Exception {
+        Channel visitorChannel = ctx.channel();
+        InetSocketAddress sa = (InetSocketAddress) visitorChannel.localAddress();
+
+        // 判断IP是否在该端口绑定的安全组允许的规则内
+        if (!securityGroupService.judgeAllow(IpUtil.getRemoteIp(ctx), portMappingService.getSecurityGroupIdByMappingPort(sa.getPort()))) {
+            // 不在安全组规则放行范围内
+            ctx.channel().close();
+            return;
+        }
+
+        // 继续传播
+        ctx.fireChannelActive();
+    }
+
+}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/proxy/security/UdpVisitorSecurityChannelHandler.java

@@ -0,0 +1,39 @@
+package org.dromara.neutrinoproxy.server.proxy.security;
+
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.channel.socket.DatagramPacket;
+import lombok.extern.slf4j.Slf4j;
+import org.dromara.neutrinoproxy.core.Constants;
+import org.dromara.neutrinoproxy.server.service.PortMappingService;
+import org.dromara.neutrinoproxy.server.service.SecurityGroupService;
+import org.noear.solon.Solon;
+
+import java.net.InetSocketAddress;
+
+/**
+ * @author: aoshiguchen
+ * @date: 2023/12/14
+ */
+@Slf4j
+public class UdpVisitorSecurityChannelHandler extends ChannelInboundHandlerAdapter {
+    private final SecurityGroupService securityGroupService = Solon.context().getBean(SecurityGroupService.class);
+    private final PortMappingService portMappingService = Solon.context().getBean(PortMappingService.class);
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        Channel visitorChannel = ctx.channel();
+        InetSocketAddress sa = (InetSocketAddress) visitorChannel.localAddress();
+        DatagramPacket datagramPacket = (DatagramPacket) msg;
+
+        // 判断IP是否在该端口绑定的安全组允许的规则内
+        if (!securityGroupService.judgeAllow(datagramPacket.sender().getAddress().getHostAddress(), portMappingService.getSecurityGroupIdByMappingPort(sa.getPort()))) {
+            return;
+        }
+
+        // 继续传播
+        ctx.channel().attr(Constants.SERVER_PORT).set(sa.getPort());
+        ctx.fireChannelRead(msg);
+    }
+}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/proxy/security/VisitorFlowLimiterChannelHandler.java

@@ -0,0 +1,50 @@
+package org.dromara.neutrinoproxy.server.proxy.security;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInboundHandlerAdapter;
+import io.netty.handler.traffic.ChannelTrafficShapingHandler;
+import lombok.extern.slf4j.Slf4j;
+import org.dromara.neutrinoproxy.core.Constants;
+import org.dromara.neutrinoproxy.server.service.LicenseService;
+import org.dromara.neutrinoproxy.server.service.PortMappingService;
+import org.dromara.neutrinoproxy.server.service.SecurityGroupService;
+import org.dromara.neutrinoproxy.server.service.bo.FlowLimitBO;
+import org.noear.solon.Solon;
+
+/**
+ * 访问者流量限制器
+ * @author: aoshiguchen
+ * @date: 2023/12/15
+ */
+@Slf4j
+public class VisitorFlowLimiterChannelHandler extends ChannelInboundHandlerAdapter {
+    private final PortMappingService portMappingService = Solon.context().getBean(PortMappingService.class);
+
+    @Override
+    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+        Boolean flowLimiterFlag = ctx.channel().attr(Constants.FLOW_LIMITER_FLAG).get();
+
+        if (null == flowLimiterFlag || !flowLimiterFlag) {
+            Integer serverPort = ctx.channel().attr(Constants.SERVER_PORT).get();
+            Long upLimitRate = null;
+            Long downLimitRate = null;
+            // 先获取端口映射上的限速设置
+            FlowLimitBO flowLimitBO = portMappingService.getFlowLimitByServerPort(serverPort);
+            if (null != flowLimitBO) {
+                upLimitRate = flowLimitBO.getUpLimitRate();
+                downLimitRate = flowLimitBO.getDownLimitRate();
+            }
+            if (null != upLimitRate || null != downLimitRate) {
+                // 如果不全为空，则需要做限速
+                ctx.pipeline().addAfter("flowLimiter", "trafficShaping", new ChannelTrafficShapingHandler(downLimitRate == null ? 0 : downLimitRate, upLimitRate == null ? 0 : upLimitRate, 100, 600000));
+            }
+
+            // 每个连接第一次处理之后。无论是否限速，该连接后续都不在处理，避免频繁执行影响性能
+            ctx.channel().attr(Constants.FLOW_LIMITER_FLAG).set(Boolean.TRUE);
+        }
+
+        // 继续传播
+        ctx.fireChannelRead(msg);
+    }
+
+}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/service/LicenseService.java

@@ -1,7 +1,10 @@
 package org.dromara.neutrinoproxy.server.service;
 
+import cn.hutool.cache.Cache;
+import cn.hutool.cache.CacheUtil;
 import cn.hutool.core.collection.CollectionUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
 import com.baomidou.mybatisplus.solon.plugins.pagination.Page;
 import com.google.common.collect.Sets;
@@ -29,7 +32,9 @@ import org.dromara.neutrinoproxy.server.dal.UserMapper;
 import org.dromara.neutrinoproxy.server.dal.entity.LicenseDO;
 import org.dromara.neutrinoproxy.server.dal.entity.PortMappingDO;
 import org.dromara.neutrinoproxy.server.dal.entity.UserDO;
+import org.dromara.neutrinoproxy.server.service.bo.FlowLimitBO;
 import org.dromara.neutrinoproxy.server.util.ParamCheckUtil;
+import org.dromara.neutrinoproxy.server.util.StringUtil;
 import org.noear.solon.annotation.Component;
 import org.noear.solon.annotation.Init;
 import org.noear.solon.annotation.Inject;
@@ -63,6 +68,8 @@ public class LicenseService implements LifecycleBean {
     private VisitorChannelService visitorChannelService;
     @Inject
     private DBInitialize dbInitialize;
+    // 流量限制缓存
+    private final Cache<Integer, FlowLimitBO> flowLimitCache = CacheUtil.newLRUCache(200, 1000 * 60 * 5);
 
     public PageInfo<LicenseListRes> page(PageQuery pageQuery, LicenseListReq req) {
         Page<LicenseDO> page = licenseMapper.selectPage(new Page<>(pageQuery.getCurrent(), pageQuery.getSize()), new LambdaQueryWrapper<LicenseDO>()
@@ -128,15 +135,21 @@ public class LicenseService implements LifecycleBean {
         String key = UUID.randomUUID().toString().replaceAll("-", "");
         Date now = new Date();
 
-        licenseMapper.insert(new LicenseDO()
-                .setName(req.getName())
-                .setKey(key)
-                .setUserId(req.getUserId())
-                .setIsOnline(OnlineStatusEnum.OFFLINE.getStatus())
-                .setEnable(EnableStatusEnum.ENABLE.getStatus())
-                .setCreateTime(now)
-                .setUpdateTime(now)
-        );
+        licenseDO = new LicenseDO()
+            .setName(req.getName())
+            .setKey(key)
+            .setUserId(req.getUserId())
+            .setUpLimitRate(req.getUpLimitRate())
+            .setDownLimitRate(req.getDownLimitRate())
+            .setIsOnline(OnlineStatusEnum.OFFLINE.getStatus())
+            .setEnable(EnableStatusEnum.ENABLE.getStatus())
+            .setCreateTime(now)
+            .setUpdateTime(now);
+
+        licenseMapper.insert(licenseDO);
+
+        // 刷新流量限制缓存
+        refreshFlowLimitCache(licenseDO.getId(), licenseDO.getUpLimitRate(), licenseDO.getDownLimitRate());
         return new LicenseCreateRes();
     }
 
@@ -147,7 +160,17 @@ public class LicenseService implements LifecycleBean {
         LicenseDO licenseCheck = licenseMapper.checkRepeat(oldLicenseDO.getUserId(), req.getName(), Sets.newHashSet(oldLicenseDO.getId()));
         ParamCheckUtil.checkMustNull(licenseCheck, ExceptionConstant.LICENSE_NAME_CANNOT_REPEAT);
 
-        licenseMapper.update(req.getId(), req.getName(), new Date());
+        licenseMapper.update(null, new LambdaUpdateWrapper<LicenseDO>()
+            .eq(LicenseDO::getId, req.getId())
+            .set(LicenseDO::getName, req.getName())
+            .set(LicenseDO::getUpLimitRate, req.getUpLimitRate())
+            .set(LicenseDO::getDownLimitRate, req.getDownLimitRate())
+            .set(LicenseDO::getUpdateTime, new Date())
+        );
+
+        // 刷新流量限制缓存
+        refreshFlowLimitCache(req.getId(), req.getUpLimitRate(), req.getDownLimitRate());
+
         return new LicenseUpdateRes();
     }
 
@@ -200,6 +223,8 @@ public class LicenseService implements LifecycleBean {
         licenseMapper.deleteById(id);
         // 更新VisitorChannel
         visitorChannelService.updateVisitorChannelByLicenseId(id, EnableStatusEnum.DISABLE.getStatus());
+        // 删除流量限制缓存
+        flowLimitCache.remove(id);
     }
 
     /**
@@ -243,10 +268,51 @@ public class LicenseService implements LifecycleBean {
         if (NativeDetector.isAotRuntime()) {
             return;
         }
+        // 服务刚启动，所以默认所有license都是离线状态。解决服务突然关闭，在线状态来不及更新的问题
         licenseMapper.updateOnlineStatus(OnlineStatusEnum.OFFLINE.getStatus(), new Date());
+        // 刷新流量限制缓存
+        List<LicenseDO> licenseDOList = licenseMapper.listAll();
+        if (CollectionUtils.isEmpty(licenseDOList)) {
+            for (LicenseDO licenseDO : licenseDOList) {
+                refreshFlowLimitCache(licenseDO.getId(), licenseDO.getUpLimitRate(), licenseDO.getDownLimitRate());
+            }
+        }
     }
 
 
+    /**
+     * 刷新流量限制缓存
+     * @param id
+     * @param upLimitRate
+     * @param downLimitRate
+     */
+    private void refreshFlowLimitCache(Integer id, String upLimitRate, String downLimitRate) {
+        if (null == id) {
+            return;
+        }
+        flowLimitCache.put(id, new FlowLimitBO()
+            .setUpLimitRate(StringUtil.parseBytes(upLimitRate))
+            .setDownLimitRate(StringUtil.parseBytes(downLimitRate))
+        );
+    }
+
+    /**
+     * 获取license的流量限制
+     * @param licenseId
+     * @return
+     */
+    public FlowLimitBO getFlowLimit(Integer licenseId) {
+        FlowLimitBO res = flowLimitCache.get(licenseId);
+        if (null == res) {
+            LicenseDO licenseDO = licenseMapper.queryById(licenseId);
+            if (null != licenseDO) {
+                refreshFlowLimitCache(licenseId, licenseDO.getUpLimitRate(), licenseDO.getDownLimitRate());
+                res = flowLimitCache.get(licenseId);
+            }
+        }
+        return res;
+    }
+
     @Override
     public void start() throws Throwable {
 

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/service/PortMappingService.java

@@ -1,9 +1,12 @@
 package org.dromara.neutrinoproxy.server.service;
 
+import cn.hutool.cache.Cache;
+import cn.hutool.cache.CacheUtil;
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.collection.CollectionUtil;
 import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
 import com.baomidou.mybatisplus.core.toolkit.StringUtils;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
@@ -36,19 +39,17 @@ import org.dromara.neutrinoproxy.server.dal.entity.LicenseDO;
 import org.dromara.neutrinoproxy.server.dal.entity.PortMappingDO;
 import org.dromara.neutrinoproxy.server.dal.entity.PortPoolDO;
 import org.dromara.neutrinoproxy.server.dal.entity.UserDO;
+import org.dromara.neutrinoproxy.server.service.bo.FlowLimitBO;
 import org.dromara.neutrinoproxy.server.util.ParamCheckUtil;
 import org.dromara.neutrinoproxy.server.util.ProxyUtil;
+import org.dromara.neutrinoproxy.server.util.StringUtil;
 import org.noear.solon.annotation.Component;
 import org.noear.solon.annotation.Init;
 import org.noear.solon.annotation.Inject;
 import org.noear.solon.core.bean.LifecycleBean;
 import org.noear.solon.core.runtime.NativeDetector;
 
-import java.util.Comparator;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 import java.util.stream.Collectors;
@@ -76,9 +77,17 @@ public class PortMappingService implements LifecycleBean {
     private ProxyConfig proxyConfig;
     @Inject
     private DBInitialize dbInitialize;
+    @Inject
+    private LicenseService licenseService;
 
     /** 端口到安全组Id的映射 */
     private final Map<Integer, Integer> mappingPortToSecurityGroupMap = new ConcurrentHashMap<>();
+    // 服务端端口到端口映射id的映射
+    private final Cache<Integer, Integer> serverPortToPortMappingIdCache = CacheUtil.newLRUCache(500, 1000 * 60 * 10);
+    // 端口映射id到licenseId
+    private final Cache<Integer, Integer> idToLicenseIdCache = CacheUtil.newLRUCache(500, 1000 * 60 * 10);
+    // 流量限制缓存
+    private final Cache<Integer, FlowLimitBO> flowLimitCache = CacheUtil.newLRUCache(500, 1000 * 60 * 5);
 
     public PageInfo<PortMappingListRes> page(PageQuery pageQuery, PortMappingListReq req) {
         if (StringUtils.isNotEmpty(req.getDescription())) {
@@ -129,7 +138,9 @@ public class PortMappingService implements LifecycleBean {
             }
         });
         //sorted [userId asc] [licenseId asc] [createTime asc]
-        respList = respList.stream().sorted(Comparator.comparing(PortMappingListRes::getUserId).thenComparing(PortMappingListRes::getLicenseId).thenComparing(PortMappingListRes::getCreateTime)).collect(Collectors.toList());
+        respList = respList.stream()
+            .filter(e -> null != e.getUserId())
+            .sorted(Comparator.comparing(PortMappingListRes::getUserId).thenComparing(PortMappingListRes::getLicenseId).thenComparing(PortMappingListRes::getCreateTime)).collect(Collectors.toList());
         return PageInfo.of(respList, page.getTotal(), pageQuery.getCurrent(), pageQuery.getSize());
     }
 
@@ -153,6 +164,8 @@ public class PortMappingService implements LifecycleBean {
         portMappingDO.setServerPort(req.getServerPort());
         portMappingDO.setClientIp(req.getClientIp());
         portMappingDO.setClientPort(req.getClientPort());
+        portMappingDO.setUpLimitRate(req.getUpLimitRate());
+        portMappingDO.setDownLimitRate(req.getDownLimitRate());
         portMappingDO.setProxyResponses(req.getProxyResponses());
         portMappingDO.setProxyTimeoutMs(req.getProxyTimeoutMs());
         portMappingDO.setDescription(req.getDescription());
@@ -170,6 +183,13 @@ public class PortMappingService implements LifecycleBean {
 
         updateMappingPortToSecurityGroupMap(portMappingDO.getServerPort(), req.getSecurityGroupId());
 
+        // 更新端口到映射的缓存
+        serverPortToPortMappingIdCache.put(req.getServerPort(), portMappingDO.getId());
+        // 更新端口映射到licenseId的缓存
+        idToLicenseIdCache.put(portMappingDO.getId(), portMappingDO.getLicenseId());
+        // 刷新流量限制缓存
+        refreshFlowLimitCache(portMappingDO.getId(), portMappingDO.getUpLimitRate(), portMappingDO.getDownLimitRate());
+
         return new PortMappingCreateRes();
     }
 
@@ -189,15 +209,25 @@ public class PortMappingService implements LifecycleBean {
         PortMappingDO oldPortMappingDO = portMappingMapper.findById(req.getId());
         ParamCheckUtil.checkNotNull(oldPortMappingDO, ExceptionConstant.PORT_MAPPING_NOT_EXIST);
 
-        PortMappingDO portMappingDO = new PortMappingDO();
-        BeanUtil.copyProperties(req, portMappingDO);
-        if (req.getSecurityGroupId() == null) {
-            portMappingDO.setSecurityGroupId(0);
-        }
-        portMappingDO.setUpdateTime(new Date());
-        portMappingDO.setEnable(EnableStatusEnum.ENABLE.getStatus());
-        portMappingMapper.updateById(portMappingDO);
+        // 更新端口映射
+        portMappingMapper.update(null, new LambdaUpdateWrapper<PortMappingDO>()
+            .eq(PortMappingDO::getId, req.getId())
+            .set(PortMappingDO::getProtocal, req.getProtocal())
+            .set(PortMappingDO::getSubdomain, req.getSubdomain())
+            .set(PortMappingDO::getServerPort, req.getServerPort())
+            .set(PortMappingDO::getClientIp, req.getClientIp())
+            .set(PortMappingDO::getClientPort, req.getClientPort())
+            .set(PortMappingDO::getUpLimitRate, req.getUpLimitRate())
+            .set(PortMappingDO::getDownLimitRate, req.getDownLimitRate())
+            .set(PortMappingDO::getProxyTimeoutMs, req.getProxyTimeoutMs())
+            .set(PortMappingDO::getProxyResponses, req.getProxyResponses())
+            .set(PortMappingDO::getSecurityGroupId, req.getSecurityGroupId())
+            .set(PortMappingDO::getDescription, req.getDescription())
+            .set(PortMappingDO::getUpdateTime, new Date())
+        );
+
         // 更新VisitorChannel
+        PortMappingDO portMappingDO = portMappingMapper.findById(req.getId());
         visitorChannelService.updateVisitorChannelByPortMapping(oldPortMappingDO, portMappingDO);
         // 删除老的域名映射
         if (NetworkProtocolEnum.isHttp(oldPortMappingDO.getProtocal()) && StrUtil.isNotBlank(oldPortMappingDO.getSubdomain())) {
@@ -209,6 +239,13 @@ public class PortMappingService implements LifecycleBean {
         }
 
         updateMappingPortToSecurityGroupMap(portMappingDO.getServerPort(), req.getSecurityGroupId());
+
+        // 更新端口到映射的缓存
+        serverPortToPortMappingIdCache.put(req.getServerPort(), req.getId());
+        // 更新端口映射到licenseId的缓存
+        idToLicenseIdCache.put(portMappingDO.getId(), portMappingDO.getLicenseId());
+        // 刷新流量限制缓存
+        refreshFlowLimitCache(req.getId(), req.getUpLimitRate(), req.getDownLimitRate());
     }
 
     public PortMappingDetailRes detail(Integer id) {
@@ -285,6 +322,11 @@ public class PortMappingService implements LifecycleBean {
         }
 
         updateMappingPortToSecurityGroupMap(portMappingDO.getServerPort(), null);
+
+        // 删除id到licenseId的映射
+        idToLicenseIdCache.remove(id);
+        // 删除流量限制缓存
+        flowLimitCache.remove(id);
     }
 
     public void portBindSecurityGroup(Integer portMappingId, Integer groupId) {
@@ -333,6 +375,7 @@ public class PortMappingService implements LifecycleBean {
         if (NativeDetector.isAotRuntime()) {
             return;
         }
+        // 服务刚启动，所以默认所有license都是离线状态。解决服务突然关闭，在线状态来不及更新的问题
         portMappingMapper.updateOnlineStatus(OnlineStatusEnum.OFFLINE.getStatus(), new Date());
 
         List<PortMappingDO> allMappingDOList = portMappingMapper.selectList(Wrappers.lambdaQuery(PortMappingDO.class));
@@ -341,6 +384,12 @@ public class PortMappingService implements LifecycleBean {
             if (securityGroupId != null && securityGroupId > 0) {
                 updateMappingPortToSecurityGroupMap(item.getServerPort(), item.getSecurityGroupId());
             }
+            // 更新端口到映射的缓存
+            serverPortToPortMappingIdCache.put(item.getServerPort(), item.getId());
+            // 更新端口映射到licenseId的缓存
+            idToLicenseIdCache.put(item.getId(), item.getLicenseId());
+            // 刷新流量限制缓存
+            refreshFlowLimitCache(item.getId(), item.getUpLimitRate(), item.getDownLimitRate());
         });
 
         // 未配置域名，则不需要处理域名映射逻辑
@@ -350,7 +399,6 @@ public class PortMappingService implements LifecycleBean {
         List<PortMappingDO> portMappingDOList = allMappingDOList.stream()
             .filter(item -> NetworkProtocolEnum.HTTP.getDesc().equals(item.getProtocal()) && item.getSubdomain() != null)
             .collect(Collectors.toList());
-//      List<PortMappingDO> portMappingDOList =  portMappingMapper.selectList(new LambdaQueryWrapper<PortMappingDO>().eq(PortMappingDO::getProtocal, NetworkProtocolEnum.HTTP.getDesc()).isNotNull(PortMappingDO::getSubdomain));
         if (CollectionUtil.isEmpty(portMappingDOList)) {
             return;
         }
@@ -363,6 +411,84 @@ public class PortMappingService implements LifecycleBean {
         });
     }
 
+    /**
+     * 刷新流量限制缓存
+     * @param id
+     * @param upLimitRate
+     * @param downLimitRate
+     */
+    private void refreshFlowLimitCache(Integer id, String upLimitRate, String downLimitRate) {
+        if (null == id) {
+            return;
+        }
+        flowLimitCache.put(id, new FlowLimitBO()
+            .setUpLimitRate(StringUtil.parseBytes(upLimitRate))
+            .setDownLimitRate(StringUtil.parseBytes(downLimitRate))
+        );
+    }
+
+    /**
+     * 获取license的流量限制
+     * @param id
+     * @return
+     */
+    public FlowLimitBO getFlowLimit(Integer id) {
+        FlowLimitBO res = flowLimitCache.get(id);
+        if (null == res) {
+            PortMappingDO portMappingDO = portMappingMapper.findById(id);
+            if (null != portMappingDO) {
+                refreshFlowLimitCache(id, portMappingDO.getUpLimitRate(), portMappingDO.getDownLimitRate());
+                res = flowLimitCache.get(id);
+            }
+        }
+        return res;
+    }
+
+    public Integer getPortMappingIdByServerPort(Integer serverPort) {
+        if (null == serverPort) {
+            return null;
+        }
+        Integer id = serverPortToPortMappingIdCache.get(serverPort);
+        if (null != id) {
+            return id;
+        }
+        List<PortMappingDO> portMappingDOList = portMappingMapper.findListByServerPort(serverPort);
+        // 不存在 或者 有多条记录，都不处理
+        if (CollectionUtils.isEmpty(portMappingDOList) || portMappingDOList.size() > 1) {
+            return null;
+        }
+        id = portMappingDOList.get(0).getId();
+        serverPortToPortMappingIdCache.put(serverPort, id);
+        return id;
+    }
+
+    public Integer getLicenseIdById(Integer id) {
+        Integer licenseId = idToLicenseIdCache.get(id);
+        if (null == licenseId) {
+            PortMappingDO portMappingDO = portMappingMapper.findById(id);
+            if (null != portMappingDO) {
+                licenseId = portMappingDO.getLicenseId();
+                idToLicenseIdCache.put(id, licenseId);
+            }
+        }
+        return licenseId;
+    }
+
+    public FlowLimitBO getFlowLimitByServerPort(Integer serverPort) {
+        Integer id = getPortMappingIdByServerPort(serverPort);
+        if (null == id) {
+            return null;
+        }
+        FlowLimitBO res = getFlowLimit(id);
+        if (null == res || (null == res.getUpLimitRate() && null == res.getDownLimitRate())) {
+            Integer licenseId = getLicenseIdById(id);
+            if (null != licenseId) {
+                res = licenseService.getFlowLimit(licenseId);
+            }
+        }
+        return res;
+    }
+
     private void updateMappingPortToSecurityGroupMap(Integer serverPort, Integer securityGroupId) {
         if (securityGroupId == null || securityGroupId == 0) {
             mappingPortToSecurityGroupMap.remove(serverPort);

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/service/ProtocalService.java

@@ -23,7 +23,7 @@ public class ProtocalService {
     public List<ProtocalListRes> list() {
         return Lists.newArrayList(
                 new ProtocalListRes().setName("TCP").setEnable(Boolean.TRUE).setRemark("支持一切TCP之上的协议"),
-                new ProtocalListRes().setName("HTTP(S)").setEnable(Boolean.TRUE).setRemark("支持绑定子域名，未绑定时等价于时使用TCP。 若配置了证书，则同时支持HTTPS。"),
+                new ProtocalListRes().setName("HTTP(S)").setEnable(Boolean.TRUE).setRemark("支持绑定子域名，未绑定时等价于使用TCP。 若配置了证书，则同时支持HTTPS。"),
                 new ProtocalListRes().setName("UDP").setEnable(Boolean.TRUE).setRemark("支持UDP转发、响应。需要配合响应数、超时时间使用")
         );
     }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/service/SecurityGroupService.java

@@ -4,29 +4,36 @@ import cn.hutool.cache.Cache;
 import cn.hutool.cache.CacheUtil;
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.util.StrUtil;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
+import com.baomidou.mybatisplus.core.toolkit.StringUtils;
 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
-import jdk.jshell.Snippet;
+import com.baomidou.mybatisplus.solon.plugins.pagination.Page;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.ibatis.solon.annotation.Db;
+import org.dromara.neutrinoproxy.server.base.page.PageInfo;
+import org.dromara.neutrinoproxy.server.base.page.PageQuery;
 import org.dromara.neutrinoproxy.server.base.rest.SystemContextHolder;
 import org.dromara.neutrinoproxy.server.constant.EnableStatusEnum;
+import org.dromara.neutrinoproxy.server.constant.ExceptionConstant;
 import org.dromara.neutrinoproxy.server.constant.SecurityRulePassTypeEnum;
-import org.dromara.neutrinoproxy.server.controller.req.system.SecurityGroupCreateReq;
-import org.dromara.neutrinoproxy.server.controller.req.system.SecurityGroupUpdateReq;
-import org.dromara.neutrinoproxy.server.controller.req.system.SecurityRuleCreateReq;
-import org.dromara.neutrinoproxy.server.controller.req.system.SecurityRuleUpdateReq;
+import org.dromara.neutrinoproxy.server.controller.req.system.*;
+import org.dromara.neutrinoproxy.server.controller.res.system.*;
 import org.dromara.neutrinoproxy.server.dal.SecurityGroupMapper;
 import org.dromara.neutrinoproxy.server.dal.SecurityRuleMapper;
 import org.dromara.neutrinoproxy.server.dal.entity.SecurityGroupDO;
 import org.dromara.neutrinoproxy.server.dal.entity.SecurityRuleDO;
+import org.dromara.neutrinoproxy.server.util.ParamCheckUtil;
 import org.noear.solon.annotation.Component;
 import org.noear.solon.annotation.Init;
 import org.noear.solon.core.runtime.NativeDetector;
 
+import java.util.Collections;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
 
 @Component
 @Slf4j
@@ -45,9 +52,13 @@ public class SecurityGroupService {
 
     @Init(index = 100)
     public synchronized void init() {
+        // aot 阶段，不初始化
+        if (NativeDetector.isAotRuntime()) {
+            return;
+        }
         securityGroupMap.clear();
         List<SecurityGroupDO> groupDOList = securityGroupMapper.selectList(Wrappers.lambdaQuery(SecurityGroupDO.class)
-            .eq(SecurityGroupDO::getEnable, EnableStatusEnum.ENABLE));
+            .eq(SecurityGroupDO::getEnable, EnableStatusEnum.ENABLE.getStatus()));
         groupDOList.forEach(securityGroupDO -> securityGroupMap.put(securityGroupDO.getId(), securityGroupDO));
         ipAllowControlCache.clear();
     }
@@ -56,19 +67,45 @@ public class SecurityGroupService {
         ipAllowControlCache.clear();
     }
 
-    public List<SecurityGroupDO> queryGroupList() {
-        return securityGroupMapper.selectList(Wrappers.lambdaQuery(SecurityGroupDO.class)
-            .eq(SecurityGroupDO::getUserId, SystemContextHolder.getUserId()));
+    public PageInfo<SecurityGroupListRes> groupPage(PageQuery pageQuery, SecurityGroupListReq req) {
+        if (StringUtils.isNotEmpty(req.getName())) {
+            //在应用层处理，否则sqlite不支持
+            req.setName("%" + req.getName() + "%");
+        }
+        if (StringUtils.isNotEmpty(req.getDescription())) {
+            //在应用层处理，否则sqlite不支持
+            req.setDescription("%" + req.getDescription() + "%");
+        }
+        Page<SecurityGroupDO> page = new Page<>(pageQuery.getCurrent(), pageQuery.getSize());
+        List<SecurityGroupDO> list = securityGroupMapper.selectByCondition(page, req);
+        if (CollectionUtils.isEmpty(list)) {
+            return PageInfo.of(null, page.getTotal(), pageQuery.getCurrent(), pageQuery.getSize());
+        }
+        List<SecurityGroupListRes> respList = list.stream().map(SecurityGroupDO::toListRes).collect(Collectors.toList());
+        return PageInfo.of(respList, page.getTotal(), pageQuery.getCurrent(), pageQuery.getSize());
     }
 
-    public SecurityGroupDO queryGroupOne(Integer groupId) {
-        return securityGroupMapper.selectById(groupId);
+    public List<SecurityGroupListRes> groupList() {
+        List<SecurityGroupDO> list = securityGroupMapper.selectList(Wrappers.lambdaQuery(SecurityGroupDO.class)
+            .eq(SecurityGroupDO::getUserId, SystemContextHolder.getUserId()));
+        if (CollectionUtils.isEmpty(list)) {
+            return Collections.emptyList();
+        }
+        return list.stream().map(SecurityGroupDO::toListRes).collect(Collectors.toList());
+    }
+
+    public SecurityGroupDetailRes groupDetail(SecurityGroupDetailReq req) {
+        SecurityGroupDO securityGroupDO = securityGroupMapper.selectById(req.getId());
+        if (null != securityGroupDO) {
+            return securityGroupDO.toDetailRes();
+        }
+        return null;
     }
 
     public void createGroup(SecurityGroupCreateReq req) {
         SecurityGroupDO groupDO = new SecurityGroupDO();
         BeanUtil.copyProperties(req, groupDO);
-        groupDO.setEnable(EnableStatusEnum.ENABLE)
+        groupDO.setEnable(EnableStatusEnum.ENABLE.getStatus())
             .setUserId(SystemContextHolder.getUserId())
             .setCreateTime(new Date())
             .setUpdateTime(new Date());
@@ -87,16 +124,6 @@ public class SecurityGroupService {
         init();
     }
 
-    public void setGroupStatus(Integer groupId, EnableStatusEnum statusEnum) {
-        SecurityGroupDO groupDO = securityGroupMapper.selectById(groupId);
-        if (groupDO == null) {
-            throw new RuntimeException("指定的安全组不存在");
-        }
-        groupDO.setEnable(statusEnum);
-        securityGroupMapper.updateById(groupDO);
-        init();
-    }
-
     /**
      * 删除安全组，并级联删除安全组下的规则，删除后，需缓存
      * @param groupId 安全组Id
@@ -108,11 +135,41 @@ public class SecurityGroupService {
         init();
     }
 
-    public List<SecurityRuleDO> queryRuleListByGroupId(Integer groupId) {
-        return securityRuleMapper.selectList(Wrappers.lambdaQuery(SecurityRuleDO.class)
-            .eq(SecurityRuleDO::getGroupId, groupId)
-            .orderByAsc(SecurityRuleDO::getPriority)
+    public SecurityGroupUpdateEnableStatueRes updateGroupEnableStatueReq(SecurityGroupUpdateEnableStatueReq req) {
+        SecurityGroupDO groupDO = securityGroupMapper.selectById(req.getId());
+        ParamCheckUtil.checkNotNull(groupDO, ExceptionConstant.SECURITY_GROUP_NOT_EXIST);
+
+        securityGroupMapper.updateEnableStatus(req.getId(), req.getEnable(), new Date());
+        init();
+        return new SecurityGroupUpdateEnableStatueRes();
+    }
+
+    public PageInfo<SecurityRuleListRes> rulePage(PageQuery pageQuery, SecurityRuleListReq req) {
+        if (StringUtils.isNotEmpty(req.getName())) {
+            //在应用层处理，否则sqlite不支持
+            req.setName("%" + req.getName() + "%");
+        }
+        if (StringUtils.isNotEmpty(req.getDescription())) {
+            //在应用层处理，否则sqlite不支持
+            req.setDescription("%" + req.getDescription() + "%");
+        }
+        Page<SecurityRuleDO> page = new Page<>(pageQuery.getCurrent(), pageQuery.getSize());
+        List<SecurityRuleDO> list = securityRuleMapper.selectByCondition(page, req);
+        if (CollectionUtils.isEmpty(list)) {
+            return PageInfo.of(null, page.getTotal(), pageQuery.getCurrent(), pageQuery.getSize());
+        }
+        List<SecurityRuleListRes> respList = list.stream().map(SecurityRuleDO::toListRes).collect(Collectors.toList());
+        return PageInfo.of(respList, page.getTotal(), pageQuery.getCurrent(), pageQuery.getSize());
+    }
+
+    public List<SecurityRuleListRes> ruleList(SecurityRuleListReq req) {
+        List<SecurityRuleDO> list = securityRuleMapper.selectList(new LambdaQueryWrapper<SecurityRuleDO>()
+                .eq(null != req.getGroupId(), SecurityRuleDO::getGroupId, req.getGroupId())
         );
+        if (CollectionUtils.isEmpty(list)) {
+            return Collections.emptyList();
+        }
+        return list.stream().map(SecurityRuleDO::toListRes).collect(Collectors.toList());
     }
 
     public void createRule(SecurityRuleCreateReq req) {
@@ -120,7 +177,7 @@ public class SecurityGroupService {
         BeanUtil.copyProperties(req, ruleDO);
         ruleDO.setUserId(SystemContextHolder.getUserId())
                 .setCreateTime(new Date())
-                .setEnable(EnableStatusEnum.ENABLE)
+                .setEnable(EnableStatusEnum.ENABLE.getStatus())
                 .setUpdateTime(new Date());
         securityRuleMapper.insert(ruleDO);
         clearCache();
@@ -138,12 +195,13 @@ public class SecurityGroupService {
         clearCache();
     }
 
-    public void setRuleStatus(Integer ruleId, EnableStatusEnum statusEnum) {
-        SecurityRuleDO ruleDO = securityRuleMapper.selectById(ruleId);
-        ruleDO.setEnable(statusEnum);
-        ruleDO.setUpdateTime(new Date());
-        securityRuleMapper.updateById(ruleDO);
+    public SecurityRuleUpdateEnableStatueRes updateRuleEnableStatueReq(SecurityRuleUpdateEnableStatueReq req) {
+        SecurityRuleDO ruleDO = securityRuleMapper.selectById(req.getId());
+        ParamCheckUtil.checkNotNull(ruleDO, ExceptionConstant.SECURITY_RULE_NOT_EXIST);
+
+        securityRuleMapper.updateEnableStatus(req.getId(), req.getEnable(), new Date());
         clearCache();
+        return new SecurityRuleUpdateEnableStatueRes();
     }
 
     /**
@@ -156,18 +214,16 @@ public class SecurityGroupService {
         ip = ip.toLowerCase();
         // 不能判断当前连接的IP，保守处理，拒绝放行
         if (StrUtil.isEmpty(ip)) {
-            log.debug("【安全组】不能正确获取到IP地址，保守处理，拒绝放行");
+            log.debug("[SecurityGroup] cannot get remote ip,this pack be reject");
             return false;
         }
 
         // 黑名单规则，没有该安全组，则放行
         if (groupId == null) {
-            log.debug("【安全组】{}：该IP访问的端口映射没有绑定安全组（1）， 放行", ip);
             return true;
         }
         SecurityGroupDO groupDO = securityGroupMap.get(groupId);
         if (groupDO == null) {
-            log.debug("【安全组】{}：该IP访问的端口映射没有绑定安全组（2）， 放行", ip);
             return true;
         }
 
@@ -175,33 +231,33 @@ public class SecurityGroupService {
         String judgeAllowMapKey = ip + groupId;
         if (ipAllowControlCache.containsKey(judgeAllowMapKey)) {
             allow = ipAllowControlCache.get(judgeAllowMapKey);
-            log.debug("【安全组】{}-安全组{}：该IP在缓存中，缓存策略为{}", ip, groupId, allow ? "允许" : "拒绝");
+            log.debug("[SecurityGroup] ip:{} groupId:{} cached security strategy:{}", ip, groupId, allow ? "allow" : "reject");
             return allow;
         }
 
         List<SecurityRuleDO>  ruleDOList = securityRuleMapper.selectList(Wrappers.lambdaQuery(SecurityRuleDO.class)
             .eq(SecurityRuleDO::getGroupId, groupId)
-            .eq(SecurityRuleDO::getEnable, EnableStatusEnum.ENABLE)
+            .eq(SecurityRuleDO::getEnable, EnableStatusEnum.ENABLE.getStatus())
             .orderByAsc(SecurityRuleDO::getPriority)
         );
         for (SecurityRuleDO ruleDO : ruleDOList) {
             SecurityRulePassTypeEnum passType = ruleDO.judge(ip);
             if (passType == SecurityRulePassTypeEnum.ALLOW) {
                 allow = true;
-                log.debug("【安全组】{}-安全组{}：匹配到安全规则{}行为：{}", ip, groupId, ruleDO.getId(), "允许");
+                log.debug("[SecurityGroup] ip:{} groupId:{} ruleId:{} security strategy:{}", ip, groupId, ruleDO.getId(), "allow");
                 break;
             }
             if (passType == SecurityRulePassTypeEnum.DENY) {
                 allow = false;
-                log.info("【安全组】{}-安全组{}：匹配到安全规则{}行为：{}", ip, groupId, ruleDO.getId(), "拒绝");
+                log.info("[SecurityGroup] ip:{} groupId:{} ruleId:{} security strategy:{}", ip, groupId, ruleDO.getId(), "reject");
                 break;
             }
         }
 
         // 当前IP没有匹配到任何一条规则，则使用安全组默认规则
         if (allow == null) {
-            allow = groupDO.getDefaultPassType() == SecurityRulePassTypeEnum.ALLOW;
-            log.debug("【安全组】{}-安全组{}：使用安全组默认放行类型：{}", ip, groupId, allow ? "允许" : "拒绝");
+            allow = SecurityRulePassTypeEnum.ALLOW.getType().equals(groupDO.getDefaultPassType());
+            log.debug("[SecurityGroup] ip:{} groupId{} use security group default strategy:{}", ip, groupId, allow ? "allow" : "reject");
         }
 
         ipAllowControlCache.put(judgeAllowMapKey, allow);

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/service/bo/FlowLimitBO.java

@@ -0,0 +1,15 @@
+package org.dromara.neutrinoproxy.server.service.bo;
+
+import lombok.Data;
+import lombok.experimental.Accessors;
+
+/**
+ * @author: aoshiguchen
+ * @date: 2023/12/15
+ */
+@Accessors(chain = true)
+@Data
+public class FlowLimitBO {
+    private Long upLimitRate;
+    private Long downLimitRate;
+}

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/util/ParamCheckUtil.java

@@ -103,4 +103,20 @@ public class ParamCheckUtil {
         }
     }
 
+    /**
+     * 校验字节描述
+     * @param str
+     * @param params
+     */
+    public static void checkBytesDesc(String str, Object... params) {
+        // 允许为空
+        if (StrUtil.isEmpty(str)) {
+            return;
+        }
+        Long bytes = StringUtil.parseBytes(str);
+        if (null == bytes || bytes <= 0) {
+            throw ServiceException.create(ExceptionConstant.BYTES_DESC_INVALID, params);
+        }
+    }
+
 }

neutrino-proxy-server/src/main/java/org/dromara/neutrinoproxy/server/util/StringUtil.java

@@ -0,0 +1,75 @@
+package org.dromara.neutrinoproxy.server.util;
+
+import cn.hutool.core.util.StrUtil;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @author: aoshiguchen
+ * @date: 2023/12/15
+ */
+public class StringUtil {
+    private static final Integer BYTES_MUL_KB = 1024;
+    private static final Integer BYTES_MUL_MB = BYTES_MUL_KB * 1024;
+    private static final Integer BYTES_MUL_GB = BYTES_MUL_MB * 1024;
+    private static final String[] BYTES_UNIT_STR = {"B", "K", "KB", "M", "MB", "G", "GB"};
+    private static final Integer[] BYTES_UNIT_MUL = {1, BYTES_MUL_KB, BYTES_MUL_KB, BYTES_MUL_MB, BYTES_MUL_MB, BYTES_MUL_GB, BYTES_MUL_GB};
+    private static final String BYTES_DESC_REGEX = "\\s*(\\d+\\.*\\d*)\\s*(B|K|KB|M|MB|G|GB)\\s*";
+    private static final Pattern BYTES_DESC_PATTERN = Pattern.compile(BYTES_DESC_REGEX);
+
+    /**
+     * 校验是否符合字节描述
+     * @param desc
+     * @return
+     */
+    public static boolean isBytesDesc(String desc) {
+        if (StrUtil.isBlank(desc)) {
+            return false;
+        }
+        return desc.toUpperCase().matches(BYTES_DESC_REGEX);
+    }
+
+    /**
+     * 解析字节数
+     * 支持B、K、KB、M、MB、G、GB 忽略大小写、忽略首尾空格、忽略数字与单位之间的空格
+     * @param desc
+     * @return
+     */
+    public static Long parseBytes(String desc) {
+        try {
+            if (!isBytesDesc(desc)) {
+                return null;
+            }
+            Matcher matcher = BYTES_DESC_PATTERN.matcher(desc.toUpperCase());
+            boolean found = matcher.find();
+            if (!found) {
+                return null;
+            }
+            Double n = Double.parseDouble(matcher.group(1));
+            String unit = matcher.group(2);
+            Integer unitIndex = getBytesUnitIndex(unit);
+            if (null == unitIndex) {
+                return null;
+            }
+
+            return (long)(n * BYTES_UNIT_MUL[unitIndex]);
+        } catch (Exception e) {
+            // ignore
+        }
+
+        return null;
+    }
+
+    private static Integer getBytesUnitIndex(String unit) {
+        if (StrUtil.isBlank(unit)) {
+            return null;
+        }
+        for (int i = 0; i < BYTES_UNIT_STR.length; i++) {
+            if (unit.equals(BYTES_UNIT_STR[i])) {
+                return i;
+            }
+        }
+        return null;
+    }
+}

neutrino-proxy-server/src/main/resources/app-copy.yml

@@ -18,46 +18,46 @@ neutrino:
       boss-thread-count: 2
       work-thread-count: 10
       # 隧道非SSL端口
-      port: ${OPEN_PORT:9000}
+      port: 9000
       # 隧道SSL端口
-      ssl-port: ${SSL_PORT:9002}
+      ssl-port: 9002
       # 隧道SSL证书配置
-      key-store-password: ${STORE_PASS:123456}
-      key-manager-password: ${MGR_PASS:123456}
-      jks-path: ${JKS_PATH:classpath:/test.jks}
+      key-store-password: 123456
+      key-manager-password: 123456
+      jks-path: classpath:/test.jks
       # 是否开启隧道传输报文日志(日志级别为debug时开启才有效)
-      transfer-log-enable: ${TUNNEL_LOG:false}
+      transfer-log-enable: false
       # 是否开启心跳日志
-      heartbeat-log-enable: ${HEARTBEAT_LOG:false}
+      heartbeat-log-enable: false
     server:
       tcp:
         # 线程池相关配置，用于技术调优，可忽略
         boss-thread-count: 5
         work-thread-count: 20
         # http代理端口，默认80
-        http-proxy-port: ${HTTP_PROXY_PORT:80}
+        http-proxy-port: 80
         # https代理端口，默认443 （需要配置域名、证书）
-        https-proxy-port: ${HTTPS_PROXY_PORT:443}
+        https-proxy-port: 443
         # 如果不配置，则不支持域名映射
-        domain-name: ${DOMAIN_NAME:}
+        domain-name:
         # https证书配置
-        key-store-password: ${HTTPS_STORE_PASS:}
-        jks-path: ${HTTPS_JKS_PATH:}
+        key-store-password:
+        jks-path:
         # 是否开启代理服务报文日志(日志级别为debug时开启才有效)
-        transfer-log-enable: ${SERVER_LOG:false}
+        transfer-log-enable: false
       udp:
         # 线程池相关配置，用于技术调优，可忽略
         boss-thread-count: 5
         work-thread-count: 20
         # 是否开启代理服务报文日志(日志级别为debug时开启才有效)
-        transfer-log-enable: ${SERVER_LOG:false}
+        transfer-log-enable: false
   data:
     db:
       # 数据库类型，目前支持h2、mysql、mariadb
-      type: ${DB_TYPE:h2}
+      type: h2
       # 数据库连接URL
-      url: ${DB_URL:jdbc:h2:file:./data/db;MODE=MySQL;AUTO_SERVER=TRUE}
+      url: jdbc:h2:file:./data/db;MODE=MySQL;AUTO_SERVER=TRUE
       # 数据库用户名
-      username: ${DB_USER:}
+      username:
       # 数据库密码
-      password: ${DB_PASSWORD:}
+      password:

neutrino-proxy-server/src/main/resources/app.yml

@@ -5,7 +5,7 @@ server:
 solon:
   app:
     name: neutrino-proxy-server
-    version: @revision@
+    version: 2.0.1
   config:
     add: ./app.yml
 # 日志级别

neutrino-proxy-server/src/main/resources/mapper/SecurityGroupMapper.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="org.dromara.neutrinoproxy.server.dal.SecurityGroupMapper">
+
+    <select id="selectByCondition" resultType="org.dromara.neutrinoproxy.server.dal.entity.SecurityGroupDO">
+        SELECT sg.* from security_group sg
+        <where>
+            <if test="req.name != null and req.name != '' ">
+                AND sg.name like #{req.name}
+            </if>
+            <if test="req.description != null and req.description != '' ">
+                AND sg.description like #{req.description}
+            </if>
+            <if test="req.defaultPassType != null">
+                AND sg.default_pass_type like #{req.defaultPassType}
+            </if>
+            <if test="req.enable != null">
+                AND sg.enable like #{req.enable}
+            </if>
+        </where>
+        order by sg.id DESC
+    </select>
+</mapper>

neutrino-proxy-server/src/main/resources/mapper/SecurityRuleMapper.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="org.dromara.neutrinoproxy.server.dal.SecurityRuleMapper">
+
+    <select id="selectByCondition" resultType="org.dromara.neutrinoproxy.server.dal.entity.SecurityRuleDO">
+        SELECT sr.* from security_rule sr
+        <where>
+            <if test="req.groupId != null">
+                AND sr.group_id = ${req.groupId}
+            </if>
+            <if test="req.name != null and req.name != '' ">
+                AND sr.name like #{req.name}
+            </if>
+            <if test="req.description != null and req.description != '' ">
+                AND sr.description like #{req.description}
+            </if>
+            <if test="req.passType != null">
+                AND sr.pass_type like #{req.passType}
+            </if>
+            <if test="req.enable != null">
+                AND sr.enable like #{req.enable}
+            </if>
+        </where>
+        order by sr.id DESC
+    </select>
+</mapper>

neutrino-proxy-server/src/main/resources/sql/h2/init-structure.sql

@@ -52,8 +52,8 @@ CREATE TABLE IF NOT EXISTS `security_group` (
     `name` VARCHAR(20) NOT NULL,
     `description` VARCHAR(255),
     `user_id` INTEGER NOT NULL,
-    `enable` VARCHAR(20) NOT NULL,
-    `default_pass_type` VARCHAR(20) NOT NULL,
+    `enable` INTEGER NOT NULL,
+    `default_pass_type` INTEGER NOT NULL,
     `create_time` TIMESTAMP NOT NULL,
     `update_time` TIMESTAMP NOT NULL,
     PRIMARY KEY (`id`)
@@ -66,10 +66,10 @@ CREATE TABLE IF NOT EXISTS `security_rule` (
     `name` VARCHAR(20) NOT NULL,
     `description` VARCHAR(255) NOT NULL,
     `rule` text NOT NULL,
-    `pass_type` VARCHAR(20) NOT NULL,
+    `pass_type` INTEGER NOT NULL,
     `priority` INTEGER NOT NULL,
     `user_id` INTEGER NOT NULL,
-    `enable` VARCHAR(20) NOT NULL,
+    `enable` INTEGER NOT NULL,
     `create_time` TIMESTAMP NOT NULL,
     `update_time` TIMESTAMP NOT NULL,
     PRIMARY KEY (`id`)
@@ -83,6 +83,8 @@ CREATE TABLE IF NOT EXISTS `license` (
     `name` VARCHAR(50) NOT NULL,
     `key` VARCHAR(100) NOT NULL,
     `user_id` INTEGER NOT NULL,
+    `up_limit_rate` VARCHAR(20) DEFAULT NULL,
+    `down_limit_rate` VARCHAR(20) DEFAULT NULL,
     `is_online` INTEGER(2) NOT NULL,
     `enable` INTEGER(2) NOT NULL,
     `create_time` TIMESTAMP NOT NULL,
@@ -99,6 +101,8 @@ CREATE TABLE IF NOT EXISTS `port_mapping` (
   `server_port` INTEGER NOT NULL,
   `client_ip` VARCHAR(20) NOT NULL,
   `client_port` INTEGER NOT NULL,
+  `up_limit_rate` VARCHAR(20) DEFAULT NULL,
+  `down_limit_rate` VARCHAR(20) DEFAULT NULL,
   `is_online` INTEGER(2) NOT NULL,
   `description` VARCHAR(100) DEFAULT NULL,
   `proxy_responses` INTEGER(20) NOT NULL DEFAULT 0,
@@ -167,8 +171,8 @@ CREATE TABLE IF NOT EXISTS `flow_report_minute` (
     `id` INTEGER NOT NULL PRIMARY KEY AUTO_INCREMENT,
     `user_id` INTEGER(20) NOT NULL,
     `license_id` INTEGER(20) NOT NULL,
-    `write_bytes` INTEGER(20) NOT NULL,
-    `read_bytes` INTEGER(20) NOT NULL,
+    `write_bytes` bigint NOT NULL,
+    `read_bytes` bigint NOT NULL,
     `date` TIMESTAMP NOT NULL,
     `date_str` VARCHAR(20) NOT NULL,
     `create_time` TIMESTAMP NOT NULL
@@ -183,8 +187,8 @@ CREATE TABLE IF NOT EXISTS `flow_report_hour` (
     `id` INTEGER NOT NULL PRIMARY KEY AUTO_INCREMENT,
     `user_id` INTEGER(20) NOT NULL,
     `license_id` INTEGER(20) NOT NULL,
-    `write_bytes` INTEGER(20) NOT NULL,
-    `read_bytes` INTEGER(20) NOT NULL,
+    `write_bytes` bigint NOT NULL,
+    `read_bytes` bigint NOT NULL,
     `date` TIMESTAMP NOT NULL,
     `date_str` VARCHAR(20) NOT NULL,
     `create_time` TIMESTAMP NOT NULL
@@ -199,8 +203,8 @@ CREATE TABLE IF NOT EXISTS `flow_report_day` (
     `id` INTEGER NOT NULL PRIMARY KEY AUTO_INCREMENT,
     `user_id` INTEGER(20) NOT NULL,
     `license_id` INTEGER(20) NOT NULL,
-    `write_bytes` INTEGER(20) NOT NULL,
-    `read_bytes` INTEGER(20) NOT NULL,
+    `write_bytes` bigint NOT NULL,
+    `read_bytes` bigint NOT NULL,
     `date` TIMESTAMP NOT NULL,
     `date_str` VARCHAR(20) NOT NULL,
     `create_time` TIMESTAMP NOT NULL
@@ -215,8 +219,8 @@ CREATE TABLE IF NOT EXISTS `flow_report_month` (
     `id` INTEGER NOT NULL PRIMARY KEY AUTO_INCREMENT,
     `user_id` INTEGER(20) NOT NULL,
     `license_id` INTEGER(20) NOT NULL,
-    `write_bytes` INTEGER(20) NOT NULL,
-    `read_bytes` INTEGER(20) NOT NULL,
+    `write_bytes` bigint NOT NULL,
+    `read_bytes` bigint NOT NULL,
     `date` TIMESTAMP NOT NULL,
     `date_str` VARCHAR(20) NOT NULL,
     `create_time` TIMESTAMP NOT NULL

neutrino-proxy-server/src/main/resources/sql/h2/update/UPDATE-20231215.SQL

@@ -4,8 +4,8 @@ CREATE TABLE IF NOT EXISTS `security_group` (
     `name` VARCHAR(20) NOT NULL,
     `description` VARCHAR(255),
     `user_id` INTEGER NOT NULL,
-    `enable` VARCHAR(20) NOT NULL,
-    `default_pass_type` VARCHAR(20) NOT NULL,
+    `enable` INTEGER NOT NULL,
+    `default_pass_type` INTEGER NOT NULL,
     `create_time` TIMESTAMP NOT NULL,
     `update_time` TIMESTAMP NOT NULL,
     PRIMARY KEY (`id`)
@@ -18,13 +18,21 @@ CREATE TABLE IF NOT EXISTS `security_rule` (
     `name` VARCHAR(20) NOT NULL,
     `description` VARCHAR(255) NOT NULL,
     `rule` text NOT NULL,
-    `pass_type` VARCHAR(20) NOT NULL,
+    `pass_type` INTEGER NOT NULL,
     `priority` INTEGER NOT NULL,
     `user_id` INTEGER NOT NULL,
-    `enable` VARCHAR(20) NOT NULL,
+    `enable` INTEGER NOT NULL,
     `create_time` TIMESTAMP NOT NULL,
     `update_time` TIMESTAMP NOT NULL,
     PRIMARY KEY (`id`)
 );
 CREATE INDEX IF NOT EXISTS I_security_rule_group_id ON security_rule(group_id);
-ALTER TABLE `port_mapping` ADD COLUMN IF NOT EXISTS `security_group_id` INTEGER DEFAULT 0;
+
+# port_mapping表增加字段
+ALTER TABLE `port_mapping` ADD COLUMN `security_group_id` INTEGER DEFAULT 0;
+ALTER TABLE `port_mapping` ADD COLUMN `up_limit_rate` varchar(20) DEFAULT NULL;
+ALTER TABLE `port_mapping` ADD COLUMN `down_limit_rate` varchar(20) DEFAULT NULL;
+
+# license表增加字段
+ALTER TABLE `license` ADD COLUMN `up_limit_rate` varchar(20) DEFAULT NULL;
+ALTER TABLE `license` ADD COLUMN `down_limit_rate` varchar(20) DEFAULT NULL;

neutrino-proxy-server/src/main/resources/sql/mariadb/init-structure.sql

@@ -56,8 +56,8 @@ CREATE TABLE IF NOT EXISTS `security_group` (
     `name` varchar(20) NOT NULL COMMENT '安全组名称',
     `description` varchar(255) COMMENT '安全组描述',
     `user_id` int NOT NULL COMMENT '用户ID',
-    `enable` varchar(20) NOT NULL COMMENT '启用状态',
-    `default_pass_type` varchar(20) NOT NULL COMMENT '默认放行类型',
+    `enable` int NOT NULL COMMENT '是否启用(1、启用 2、禁用)',
+    `default_pass_type` int NOT NULL COMMENT '默认放行类型',
     `create_time` datetime(3) NOT NULL COMMENT '创建时间',
     `update_time` datetime(3) NOT NULL COMMENT '更新时间',
     PRIMARY KEY (`id`)
@@ -70,10 +70,10 @@ CREATE TABLE IF NOT EXISTS `security_rule` (
     `name` varchar(20) NOT NULL COMMENT '规则名称',
     `description` varchar(255) NOT NULL COMMENT '规则描述',
     `rule` text NOT NULL COMMENT '规则内容',
-    `pass_type` varchar(20) NOT NULL COMMENT '放行类型',
+    `pass_type` int NOT NULL COMMENT '放行类型',
     `priority` int(1) NOT NULL COMMENT '优先级',
     `user_id` int NOT NULL COMMENT '用户ID',
-    `enable` varchar(20) NOT NULL COMMENT '启用状态',
+    `enable` int NOT NULL COMMENT '是否启用(1、启用 2、禁用)',
     `create_time` datetime(3) NOT NULL COMMENT '创建时间',
     `update_time` datetime(3) NOT NULL COMMENT '更新时间',
     PRIMARY KEY (`id`),
@@ -87,6 +87,8 @@ CREATE TABLE IF NOT EXISTS `license` (
     `name` varchar(50) NOT NULL COMMENT 'license名称',
     `key` varchar(100) NOT NULL COMMENT 'license key',
     `user_id` int NOT NULL COMMENT '用户ID',
+    `up_limit_rate` varchar(20) DEFAULT NULL COMMENT '上传限速',
+    `down_limit_rate` varchar(20) DEFAULT NULL COMMENT '下载限速',
     `is_online` int NOT NULL COMMENT '是否在线（1、在线 2、离线）',
     `enable` int NOT NULL COMMENT '是否启用(1、启用 2、禁用)',
     `create_time` datetime(3) NOT NULL COMMENT '创建时间',
@@ -104,6 +106,8 @@ CREATE TABLE IF NOT EXISTS `port_mapping` (
     `server_port` int NOT NULL COMMENT '服务端端口',
     `client_ip` varchar(20) NOT NULL COMMENT '客户端IP',
     `client_port` int NOT NULL COMMENT '客户端端口',
+    `up_limit_rate` varchar(20) DEFAULT NULL COMMENT '上传限速',
+    `down_limit_rate` varchar(20) DEFAULT NULL COMMENT '下载限速',
     `is_online` int NOT NULL COMMENT '是否在线（1、在线 2、离线）',
     `description` varchar(100) DEFAULT NULL COMMENT '描述',
     `proxy_responses` int NOT NULL DEFAULT 0 COMMENT '代理响应数据包数量',

neutrino-proxy-server/src/main/resources/sql/mysql/init-structure.sql

@@ -56,8 +56,8 @@ CREATE TABLE IF NOT EXISTS `security_group` (
     `name` varchar(20) NOT NULL COMMENT '安全组名称',
     `description` varchar(255) COMMENT '安全组描述',
     `user_id` int NOT NULL COMMENT '用户ID',
-    `enable` varchar(20) NOT NULL COMMENT '启用状态',
-    `default_pass_type` varchar(20) NOT NULL COMMENT '默认放行类型',
+    `enable` int NOT NULL COMMENT '是否启用(1、启用 2、禁用)',
+    `default_pass_type` int NOT NULL COMMENT '默认放行类型',
     `create_time` datetime(3) NOT NULL COMMENT '创建时间',
     `update_time` datetime(3) NOT NULL COMMENT '更新时间',
     PRIMARY KEY (`id`)
@@ -70,10 +70,10 @@ CREATE TABLE IF NOT EXISTS `security_rule` (
     `name` varchar(20) NOT NULL COMMENT '规则名称',
     `description` varchar(255) NOT NULL COMMENT '规则描述',
     `rule` text NOT NULL COMMENT '规则内容',
-    `pass_type` varchar(20) NOT NULL COMMENT '放行类型',
+    `pass_type` int NOT NULL COMMENT '放行类型',
     `priority` int(1) NOT NULL COMMENT '优先级',
     `user_id` int NOT NULL COMMENT '用户ID',
-    `enable` varchar(20) NOT NULL COMMENT '启用状态',
+    `enable` int NOT NULL COMMENT '是否启用(1、启用 2、禁用)',
     `create_time` datetime(3) NOT NULL COMMENT '创建时间',
     `update_time` datetime(3) NOT NULL COMMENT '更新时间',
     PRIMARY KEY (`id`),
@@ -87,6 +87,8 @@ CREATE TABLE IF NOT EXISTS `license` (
     `name` varchar(50) NOT NULL COMMENT 'license名称',
     `key` varchar(100) NOT NULL COMMENT 'license key',
     `user_id` int NOT NULL COMMENT '用户ID',
+    `up_limit_rate` varchar(20) DEFAULT NULL COMMENT '上传限速',
+    `down_limit_rate` varchar(20) DEFAULT NULL COMMENT '下载限速',
     `is_online` int NOT NULL COMMENT '是否在线（1、在线 2、离线）',
     `enable` int NOT NULL COMMENT '是否启用(1、启用 2、禁用)',
     `create_time` datetime(3) NOT NULL COMMENT '创建时间',
@@ -104,6 +106,8 @@ CREATE TABLE IF NOT EXISTS `port_mapping` (
     `server_port` int NOT NULL COMMENT '服务端端口',
     `client_ip` varchar(20) NOT NULL COMMENT '客户端IP',
     `client_port` int NOT NULL COMMENT '客户端端口',
+    `up_limit_rate` varchar(20) DEFAULT NULL COMMENT '上传限速',
+    `down_limit_rate` varchar(20) DEFAULT NULL COMMENT '下载限速',
     `is_online` int NOT NULL COMMENT '是否在线（1、在线 2、离线）',
     `description` varchar(100) DEFAULT NULL COMMENT '描述',
     `proxy_responses` int NOT NULL DEFAULT 0 COMMENT '代理响应数据包数量',

neutrino-proxy-server/src/main/resources/sql/mysql/update/UPDATE-20231215.SQL

@@ -4,8 +4,8 @@ CREATE TABLE IF NOT EXISTS `security_group` (
     `name` varchar(20) NOT NULL COMMENT '安全组名称',
     `description` varchar(255) COMMENT '安全组描述',
     `user_id` int NOT NULL COMMENT '用户ID',
-    `enable` varchar(20) NOT NULL COMMENT '启用状态',
-    `default_pass_type` varchar(20) NOT NULL COMMENT '默认放行类型',
+    `enable` int NOT NULL COMMENT '是否启用(1、启用 2、禁用)',
+    `default_pass_type` int NOT NULL COMMENT '默认放行类型',
     `create_time` datetime(3) NOT NULL COMMENT '创建时间',
     `update_time` datetime(3) NOT NULL COMMENT '更新时间',
     PRIMARY KEY (`id`)
@@ -18,10 +18,10 @@ CREATE TABLE IF NOT EXISTS `security_rule` (
     `name` varchar(20) NOT NULL COMMENT '规则名称',
     `description` varchar(255) NOT NULL COMMENT '规则描述',
     `rule` text NOT NULL COMMENT '规则内容',
-    `pass_type` varchar(20) NOT NULL COMMENT '放行类型',
+    `pass_type`int NOT NULL COMMENT '放行类型',
     `priority` int(1) NOT NULL COMMENT '优先级',
     `user_id` int NOT NULL COMMENT '用户ID',
-    `enable` varchar(20) NOT NULL COMMENT '启用状态',
+    `enable` int NOT NULL COMMENT '是否启用(1、启用 2、禁用)',
     `create_time` datetime(3) NOT NULL COMMENT '创建时间',
     `update_time` datetime(3) NOT NULL COMMENT '更新时间',
     PRIMARY KEY (`id`),
@@ -30,3 +30,9 @@ CREATE TABLE IF NOT EXISTS `security_rule` (
 
 # port_mapping表增加字段
 ALTER TABLE `port_mapping` ADD COLUMN `security_group_id` int DEFAULT 0 COMMENT '安全组Id';
+ALTER TABLE `port_mapping` ADD COLUMN `up_limit_rate` varchar(20) DEFAULT NULL COMMENT '上传限速';
+ALTER TABLE `port_mapping` ADD COLUMN `down_limit_rate` varchar(20) DEFAULT NULL COMMENT '下载限速';
+
+# license表增加字段
+ALTER TABLE `license` ADD COLUMN `up_limit_rate` varchar(20) DEFAULT NULL COMMENT '上传限速';
+ALTER TABLE `license` ADD COLUMN `down_limit_rate` varchar(20) DEFAULT NULL COMMENT '下载限速';

neutrino-proxy-server/src/test/java/org/dromara/neutrinoproxy/server/VersionTest.java

@@ -1,19 +0,0 @@
-package org.dromara.neutrinoproxy.server;
-
-import org.dromara.neutrinoproxy.core.util.NeutrinoProxyVersion;
-import org.dromara.neutrinoproxy.server.app.AppBaseTest;
-import org.junit.Assert;
-import org.junit.Test;
-
-/**
- * @author songyinyin
- * @since 2023/10/31 11:51
- */
-public class VersionTest extends AppBaseTest {
-
-    @Test
-    public void testVersion() {
-        Assert.assertNotNull(NeutrinoProxyVersion.getVersion());
-        System.out.println("version: " + NeutrinoProxyVersion.getVersion());
-    }
-}

neutrino-proxy-server/src/test/java/org/dromara/neutrinoproxy/server/app/AppBaseTest.java

@@ -1,15 +0,0 @@
-package org.dromara.neutrinoproxy.server.app;
-
-import org.dromara.neutrinoproxy.server.ProxyServer;
-import org.junit.runner.RunWith;
-import org.noear.solon.test.SolonJUnit4ClassRunner;
-import org.noear.solon.test.SolonTest;
-
-/**
- * @author songyinyin
- * @since 2023/10/31 11:56
- */
-@SolonTest(value = ProxyServer.class, properties = "server.port=18888")
-@RunWith(SolonJUnit4ClassRunner.class)
-public class AppBaseTest {
-}

neutrino-proxy-vuepress/docs/01.使用教程/01.安装部署/01.快速上手.md

@@ -6,13 +6,7 @@ article: false
 ---
 
 ::: tip
-当前最新版本为2.0.0，如果从之前的版本升级而来，请注意以下变更
-
-1、jdk版本升级为了jdk17，jar部署时请注意
-
-2、去掉了默认的sqlite数据库，改为了h2。如果之前使用sqlite，请自行处理数据迁移
-
-3、配置文件做了较大调整，请参照使用须知中的`服务端配置`、`客户端配置`进行更新
+当前最新版本：2.0.1。从之前的版本升级过来，请参照：更新记录 > 版本记录
 :::
 
 ## 1、快速上手须知

neutrino-proxy-vuepress/docs/01.使用教程/01.安装部署/02.使用jar部署.md

@@ -5,13 +5,13 @@ permalink: /pages/eebea1/
 ---
 
 ## 1、环境准备
-- 首先确保已安装Java17运行环境
-- 打开[发行版页面](https://gitee.com/dromara/neutrino-proxy/releases)，下载最新的release包：`neutrino-proxy-server-jar.zip`、`neutrino-proxy-client-jar.zip`
+- 首先确保已安装Java21运行环境
+- 打开[发行版页面](https://gitee.com/dromara/neutrino-proxy/releases)，下载最新的release包：`neutrino-proxy-server-jdk21-2.0.1-jar.zip`、`neutrino-proxy-client-jdk21-2.0.1-jar.zip`
 
 
 ## 2、部署服务端
 - 在服务器上新建部署目录：`/work/projects/neutrino-proxy-server`
-- 将`neutrino-proxy-server-jar.zip`上传至服务器部署目录,并解压
+- 将`neutrino-proxy-server-jdk21-2.0.1-jar.zip`上传至服务器部署目录,并解压
 - 执行命令`java -Dfile.encoding=utf-8 -jar neutrino-proxy-server.jar`启动服务端完成部署，默认使用h2数据库。
 - 若需要指定自己的mysql数据库，则需要在当前目录下的`app.yml`文件中，修改数据库配置如下：
 
@@ -32,7 +32,7 @@ neutrino:
 - 可参照 https://gitee.com/dromara/neutrino-proxy/blob/master/scripts/unix/server_start.sh 使用shell脚本启动服务端。
 
 ## 3、部署客户端
-- 本地解压`neutrino-proxy-client-jar.zip`文件
+- 本地解压`neutrino-proxy-client-jdk21-2.0.1-jar.zip`文件
 - 修改`app.yml`文件中的server-ip为服务器公网ip，并配置license-key，以下是相关的部分配置：
 ```yml
 neutrino:

neutrino-proxy-vuepress/docs/01.使用教程/01.安装部署/03.使用docker容器化部署.md

@@ -12,7 +12,7 @@ docker run -it -p 9000-9200:9000-9200/tcp -p 8888:8888 \
 -v /root/neutrino-proxy-server/config:/root/neutrino-proxy/config \
 -v /root/neutrino-proxy-server/data:/root/neutrino-proxy/data \
 -v /root/neutrino-proxy-server/logs:/root/neutrino-proxy/logs \
-registry.cn-hangzhou.aliyuncs.com/asgc/neutrino-proxy:latest
+aoshiguchen/neutrino-proxy-server:latest
 ```
 
 ### 指定自己的mysql数据库

neutrino-proxy-vuepress/docs/01.使用教程/01.安装部署/04.原生部署.md

@@ -18,7 +18,7 @@ permalink: /pages/69699a/
 
 ## 1、安装包下载
 - 打开[发行版页面](https://gitee.com/dromara/neutrino-proxy/releases)，下载所需的最新的release包：
-- 比如服务器为linux则可下载`neutrino-proxy-server-ubuntu-20.04-native.zip`文件，客户端为windows则可下载`neutrino-proxy-client-windows-2022-native.zip`
+- 比如服务器为linux则可下载`neutrino-proxy-server-linux-2.0.1-native.zip`文件，客户端为windows则可下载`neutrino-proxy-client-windows-2.0.1-native.zip`
 
 ## 2、部署服务端
 - 将服务端安装包上传至服务器，并解压

neutrino-proxy-vuepress/docs/01.使用教程/02.使用须知/01.管理后台.md

@@ -17,8 +17,22 @@ article: false
 # 代理配置
 - License管理：License是客户端连接服务端的唯一合法凭证。一个License同时只能被一个客户端使用，一个License可以维护多条端口映射
 - 端口映射：服务端IP+端口 -> 客户端IP+端口的四元组映射(因目前服务端单节点只有一个公网IP，所以不体现出来)，是内网穿透的基本单元。
+- 限速：
+  - 默认所有代理没有限速
+  - 对License限速，将使得License下的所有端口映射都被限速
+  - 若License设置了限速，License下的某条映射也设置了限速，则对于该映射优先采用端口映射上的限速规则
+
+<img :src="$withBase('/img/run-example/license2.png')"></img>
+<img :src="$withBase('/img/run-example/port-mapping2.png')"></img>
+
+# 安全组
+一个端口映射可绑定一个安全组，通过安全组的默认放行类型 + 安全组下的安全规则 控制该端口映射的安全访问规则。
+- 场景1: 内部服务，穿透出来自己使用，不希望被其他人访问。端口映射可关联一个默认放行类型为“拒绝”的安全组，安全组下新增安全规则，将本地的出口ip添加到允许放行规则中。
+- 场景2：公网服务，穿透出来开放给大家使用，但是希望拒绝某些IP访问。端口映射可关联一个默认放行类型为“允许”的安全组，安全组下新增安全规则，将黑名单ip添加到拒绝放行规则中。
+
+<img :src="$withBase('/img/run-example/security-group1.png')"></img>
+<img :src="$withBase('/img/run-example/security-rule1.png')"></img>
 
-<img :src="$withBase('/img/run-example/license1.png')"></img>
 
 # 系统管理
 - 用户管理：支持多用户，一个用户可持有多个License。由于项目目前主推个人版，所以暂是没有权限这一套，管理员之外的所有用户都属于游客。对于绝大多数操作，游客仅有只读权限。
@@ -44,4 +58,4 @@ article: false
 - 登录日志：管理后端登录、退出登录的日志
 - 客户端连接日志：客户端连接、断开的日志
 
-<img :src="$withBase('/img/run-example/login-log1.png')"></img>
+<img :src="$withBase('/img/run-example/login-log1.png')"></img>

neutrino-proxy-vuepress/docs/03.支持我们/01.个人赞赏.md

@@ -11,9 +11,9 @@ permalink: /pages/1ab20b/
 |:-----|:-----|:----------------------|
 | 任意金额 | -    | 您将获得赞助者列表的永久留名。       |
 | 30   | 一个月  | 您在群内反馈的问题将优先得到作者响应    |
-| 80   | 三个月  | 获得微信一对一的咨询服务          |
-| 180  | 三个月  | 获得官网首页特别赞助席位一个，一次远程协助 |
-| 更多金额 |-| 您将获得私人定制服务            |
+| 120  | 三个月  | 获得微信一对一的咨询服务          |
+| 399  | 六个月  | 获得官网首页特别赞助席位一个，一次远程协助 |
+| 更多金额 | -    | 您将获得私人定制服务            |
 
 > 注意1：服务项目是逐级叠加：如，您赞赏的金额是 80 员那么您将享受：任意金额、一个月、三个月的服务内容
 

neutrino-proxy-vuepress/docs/03.支持我们/99.赞赏公示/100.2023年.md

@@ -6,6 +6,15 @@ permalink: /pages/cded59/
 
 | 日期         | 渠道 | 金额   |昵称| 备注               |
 |:-----------|:---|:-----|:-|:-----------------|
+|2023-12-28|微信红包|50|雪猫|请大佬吃肯德基|
+|2023-12-27|微信红包|50|D|请大佬喝杯茶|
+|2023-12-25|微信赞赏码|30|Simen|伟大的项目，尽点绵薄之力|
+|2023-12-25|微信红包|50|KAI|大佬加油|
+|2023-12-22|微信赞赏|30|walking|好东西必须支持一下|
+|2023-12-21|微信红包|100|洗最大的碗|中微子越来越强大，雨哥越来越富有|
+|2023-12-15|Gitee捐助|10|一杯香梨||
+|2023-12-12|微信红包|50|喜鸽小宝||
+|2023-11-30|支付宝收款码|30|*平|大佬继续加油|
 |2023-11-30|Gitee捐助|10|26263|感谢您的开源项目！|
 |2023-11-30|微信红包|10|姫野永遠||
 | 2023-11-26 |微信转账|180|Teacher Du||

neutrino-proxy-vuepress/docs/05.更新记录/01.版本记录/98.2.x.md

@@ -4,6 +4,16 @@ date: 2023-10-26 17:43:43
 permalink: /pages/ff3519/
 ---
 
+## 2.0.1
+- jdk版本升级为21
+- 新增安全组模块，支持黑名单、白名单限制
+- 支持对用户、license限速
+- 修复HTTP(S)映射时使用tcp端口访问正常，使用域名访问偶现一直loading的问题
+- 修复HTTP(S)映射时使用映射的域名上传文件时，连接中断的问题
+- 升级须知：
+  - jdk版本升级为了jdk21，jar部署时请注意
+  - 涉及到表结构变更，执行[增量SQL](https://gitee.com/dromara/neutrino-proxy/blob/master/neutrino-proxy-server/src/main/resources/sql/mysql/update/UPDATE-20231215.SQL)
+
 ## 2.0.0
 - solon版本升级为`2.5.11`
 - jdk版本升级为17

neutrino-proxy-vuepress/docs/05.更新记录/02.里程碑.md

@@ -3,7 +3,7 @@ title: 里程碑
 date: 2023-10-26 17:41:26
 permalink: /pages/e406dd/
 ---
-
+- 2023-12-21 2.0.1版本发布，jdk版本升级到21，支持安全组(黑/白名单IP限制)、限速
 - 2023-10-31 2.0.0版本发布，升级jdk版本至jdk17、支持原生编译、去掉sqlite改为默认H2数据库
 - 2023-09-25 中微子代理Gitee Star数突破1000
 - 2023-09-22 1.9.0版本发布，端口映射支持UDP协议

neutrino-proxy-vuepress/docs/index.md

@@ -13,12 +13,12 @@ features: # 可选的
     details: 首页图表、报表管理多维度流量监控。全方位掌握实时、历史代理数据。
   - title: 域名映射
     details: HTTP代理绑定子域名，开发调试三方回调更方便。
-  - title: 用户/License
-    details: 支持多用户、多客户端使用。后台禁用实时生效。
-  - title: 端口池
-    details: 对外端口统一管理，支持用户、License独占端口。
-  - title: 端口映射
-    details: 新增、编辑、删除、禁用实时生效。
+  - title: 管理后台
+    details: 使用端口池统一管理对外代理端口，支持多用户、多客户端使用。端口/用户/License/端口映射在后台禁用实时生效。
+  - title: 安全组
+    details: 安全组模块支持黑/白名单IP访问限制。
+  - title: 限速
+    details: 支持对License、端口映射限制上传、下载速率
   - title: Docker
     details: 服务端/客户端支持Docker一键部署。
   - title: 隧道SSL加密

pom.xml

@@ -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,13 +20,14 @@
         <module>neutrino-proxy-core</module>
         <module>neutrino-proxy-client</module>
         <module>neutrino-proxy-server</module>
+        <module>neutrino-proxy-client-sdk</module>
     </modules>
 
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
-        <revision>2.0.1-SNAPSHOT</revision>
+        <revision>2.0.1</revision>
 
         <native.version>0.9.28</native.version>
 

scripts/unix/client_build.sh

@@ -2,6 +2,7 @@
 # 中微子代理客户端编译打包脚本，基础参数请自行修改
 
 export JAVA_HOME=/Users/yangwen/my/service/graalvm/graalvm-community-openjdk-21.0.1+12.1/Contents/Home
+#export JAVA_HOME=/Users/yangwen/my/service/jdk/jdk17/jdk-17.0.4.1.jdk/Contents/Home
 export MAVEN_HOME=/Users/yangwen/my/service/maven/apache-maven-3.8.1
 export PATH=:$PATH:$JAVA_HOME/bin:$MAVEN_HOME/bin
 

scripts/unix/server_build.sh

@@ -2,6 +2,7 @@
 # 中微子代理服务端编译打包脚本，基础参数请自行修改
 
 export JAVA_HOME=/Users/yangwen/my/service/graalvm/graalvm-community-openjdk-21.0.1+12.1/Contents/Home
+#export JAVA_HOME=/Users/yangwen/my/service/jdk/jdk17/jdk-17.0.4.1.jdk/Contents/Home
 export MAVEN_HOME=/Users/yangwen/my/service/maven/apache-maven-3.8.1
 export PATH=:$PATH:$JAVA_HOME/bin:$MAVEN_HOME/bin