.gitignore

@@ -10,3 +10,6 @@
 
 # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
 hs_err_pid*
+/target/
+/.idea/
+/redkale.iml

README.md

@@ -1,12 +1,12 @@
-<h1>项目介绍</h1>
+<b>项目介绍</b>
 <p>
-   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Redkale (中文名: 红菜苔，一种湖北特产蔬菜) 是基于Java 8全新的微服务框架， 包含HTTP、WebSocket、TCP/UDP、数据序列化、数据缓存、依赖注入等功能。 本框架致力于简化集中式和微服务架构的开发，在增强开发敏捷性的同时保持高性能。
+   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Redkale (中文名: 红菜苔，一种湖北特产蔬菜) 是基于Java 11全新的微服务框架， 包含HTTP、WebSocket、TCP/UDP、数据序列化、数据缓存、依赖注入等功能。 本框架致力于简化集中式和微服务架构的开发，在增强开发敏捷性的同时保持高性能。
 </p>
 <strong>RedKale 有如下主要特点：</strong>
 <ol>
-<li>大量使用Java 8新特性（接口默认值、Stream、Lambda、JDk8内置的ASM等）</li>
+<li>大量使用Java 8+新特性（接口默认值、Stream、Lambda、内置的ASM、HttpClient等）</li>
 <li>提供HTTP服务，同时内置JSON功能与限时缓存功能</li>
-<li>TCP层完全使用NIO.2，并统一TCP与UDP的接口换</li>
+<li>TCP层完全使用NIO，并统一TCP与UDP的接口换</li>
 <li>提供分布式与集中式部署的无缝切换</li>
 <li>提供类似JPA功能，包含数据缓存自动同步、分表分库与简洁的数据层操作接口</li>
 <li>可以动态修改已依赖注入的资源</li>
@@ -14,14 +14,14 @@
 
 <strong>Redkale 设计理念</strong>
 <p>
-   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;作为一个全新的微服务框架，Redkale在接口定义上使用了Java 8大量的新语法，接口有默认实现、接口带静态方法、重复注解等特性，同时在设计上与主流框架有很大不同。Redkale是按组件形式设计的，而非以容器为主，几乎每个子包都是能提供独立功能的组件。如Tomcat是按容器设计的，所有web资源/配置由Tomcat控制，开发者很能难控制到Tomcat内部，而Redkale的HTTP服务只是个组件，开发者既可以自己启动和配置HttpServer，也可以把Redkale当成容器通过Redkale进程来初始化服务。Spring的Ioc容器也是如此，Redkale提供的依赖注入仅通过ResouceFactory一个类来控制，非常轻量，并且可动态更改已注入的资源。Spring提倡控制反转思想，而自身的容器却让开发者很难控制。Redkale是一个既能以组件形式也能以容器形式存在的框架。从整体上看，Redkale的架构分两层：接口和默认实现。开发者若想替换掉Redkale内置的HTTP服务而使用符合JavaEE规范的HttpServlet, 可以采用自定义协议基于JSR 340(Servlet 3.1)来实现自己的HTTP服务；若想使用Hibernate作为数据库操作，可以写一个自己的DataSource实现类；JSON的序列化和反序列化也可以使用第三方的实现；Memcached或Redis也可以作为另一个CacheSource的实现替换Redkale的默认实现。这其实包含了控制反转的思想，让框架里的各个组件均可让开发者控制。<br/>
-   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;与主流框架比，功能上Redkale显得很简单，这体现了Redkale的简易性，而并非是不足，从一个良好的设计习惯或架构上来看，有些常用功能是不需要提供的，如Redkale的HTTP服务不支持HTTPS和JSP，HTTPS比HTTP多了一层加密解密，这种密集型的计算不是Java的专长，通常提供HTTP服务的架构不会将Java动态服务器放在最前端，而是在前方会放nginx或apache，除了负载均衡还能静动分离，因此HTTPS的加解密应交给nginx这样的高性能服务器处理。Redkale再提供HTTPS服务就显得鸡肋。JSP其实算是一个落后的技术，现在是一个多样化终端的时代，终端不只局限于桌面程序和PC浏览器，还有原生App、混合式App、微信端、移动H5、提供第三方接口等各种形式的终端，这些都不是JSP能方便兼顾的，而HTTP+JSON作为通用性接口可以避免重复开发，模版引擎的功能加上各种强大的JS框架足以取代JSP。Redkale在功能上做了筛选，不会为了迎合主流而提供，而是以良好的设计思想为指导。这是Redkale的主导思维。
+   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;作为一个全新的微服务框架，Redkale在接口定义上使用了Java 8以上版本的大量新特性，接口有默认实现、接口带静态方法、重复注解等特性，同时在设计上与主流框架有很大不同。Redkale是按组件形式设计的，而非以容器为主，几乎每个子包都是能提供独立功能的组件。如Tomcat是按容器设计的，所有web资源/配置由Tomcat控制，开发者很能难控制到Tomcat内部，而Redkale的HTTP服务只是个组件，开发者既可以自己启动和配置HttpServer，也可以把Redkale当成容器通过Redkale进程来初始化服务。Spring的Ioc容器也是如此，Redkale提供的依赖注入仅通过ResouceFactory一个类来控制，非常轻量，并且可动态更改已注入的资源。Spring提倡控制反转思想，而自身的容器却让开发者很难控制。Redkale是一个既能以组件形式也能以容器形式存在的框架。从整体上看，Redkale的架构分两层：接口和默认实现。开发者若想替换掉Redkale内置的HTTP服务而使用符合JavaEE规范的HttpServlet, 可以采用自定义协议基于JSR 340(Servlet 3.1)来实现自己的HTTP服务；若想使用Hibernate作为数据库操作，可以写一个自己的DataSource实现类；JSON的序列化和反序列化也可以使用第三方的实现；Memcached或Redis也可以作为另一个CacheSource的实现替换Redkale的默认实现。这其实包含了控制反转的思想，让框架里的各个组件均可让开发者控制。<br/>
+   &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;与主流框架比，功能上Redkale显得很简单，这体现了Redkale的简易性，而并非是不足，从一个良好的设计习惯或架构上来看，有些常用功能是不需要提供的，如Redkale的HTTP服务不支持JSP, JSP其实算是一个落后的技术，现在是一个多样化终端的时代，终端不只局限于桌面程序和PC浏览器，还有原生App、混合式App、微信端、移动H5、提供第三方接口等各种形式的终端，这些都不是JSP能方便兼顾的，而HTTP+JSON作为通用性接口可以避免重复开发，模版引擎的功能加上各种强大的JS框架足以取代JSP。Redkale在功能上做了筛选，不会为了迎合主流而提供，而是以良好的设计思想为指导。这是Redkale的主导思维。
 </p>
 
 
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<h5>详情请访问:&nbsp;&nbsp;&nbsp;&nbsp;<a href='https://redkale.org' target='_blank'>https://redkale.org</a></h5>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<b>详情请访问:&nbsp;&nbsp;&nbsp;&nbsp;<a href='https://redkale.org' target='_blank'>https://redkale.org</a></b>
 
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<h5>基本文档:&nbsp;&nbsp;&nbsp;&nbsp;<a href='https://redkale.org/articles.html' target='_blank'>https://redkale.org/articles.html</a></h5>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<b>基本文档:&nbsp;&nbsp;&nbsp;&nbsp;<a href='https://redkale.org/articles.html' target='_blank'>https://redkale.org/articles.html</a></b>
 
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<h5>欢迎加入Redkale QQ群:  527523235</h5>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<b>欢迎加入Redkale QQ群:  527523235</b>
 &nbsp;

bin/apidoc.bat

@@ -1,7 +0,0 @@
-@ECHO OFF
-
-SET APP_HOME=%~dp0
-
-IF NOT EXIST "%APP_HOME%\conf\application.xml"  SET APP_HOME=%~dp0..
-
-java -DCMD=APIDOC -DAPP_HOME="%APP_HOME%" -classpath "%APP_HOME%"\lib\* org.redkale.boot.Application

bin/apidoc.cmd

@@ -0,0 +1,7 @@
+@ECHO OFF
+
+SET APP_HOME=%~dp0
+
+IF NOT EXIST "%APP_HOME%\conf\application.xml"  SET APP_HOME=%~dp0..
+
+java -DAPP_HOME="%APP_HOME%" -classpath "%APP_HOME%"\lib\* org.redkale.boot.Application apidoc

bin/apidoc.sh

@@ -15,4 +15,4 @@ do
 done
 export CLASSPATH=$CLASSPATH:$lib
 echo "$APP_HOME"
-java -DCMD=APIDOC  -DAPP_HOME="$APP_HOME"  org.redkale.boot.Application
+java -DAPP_HOME="$APP_HOME"  org.redkale.boot.Application apidoc

bin/command.bat

@@ -1,7 +0,0 @@
-@ECHO OFF
-
-SET APP_HOME=%~dp0
-
-IF NOT EXIST "%APP_HOME%\conf\application.xml"  SET APP_HOME=%~dp0..
-
-java -DCMD=%1 -DAPP_HOME="%APP_HOME%" -classpath "%APP_HOME%"\lib\* org.redkale.boot.Application

bin/redkale.cmd

@@ -0,0 +1,7 @@
+@ECHO OFF
+
+SET APP_HOME=%~dp0
+
+IF NOT EXIST "%APP_HOME%\conf\application.xml"  SET APP_HOME=%~dp0..
+
+java -DAPP_HOME="%APP_HOME%" -classpath "%APP_HOME%"\lib\* org.redkale.boot.Application %*

bin/redkale.sh

@@ -20,4 +20,4 @@ done
 export CLASSPATH=$CLASSPATH:$lib
 
 echo "$APP_HOME"
-java -DCMD=$1  -DAPP_HOME="$APP_HOME"  org.redkale.boot.Application
+java -DAPP_HOME="$APP_HOME"  org.redkale.boot.Application $@ &

bin/restart.cmd

@@ -4,6 +4,6 @@ SET APP_HOME=%~dp0
 
 IF NOT EXIST "%APP_HOME%\conf\application.xml"  SET APP_HOME=%~dp0..
 
-call "%APP_HOME%\bin\shutdown.bat" 
+call "%APP_HOME%\bin\shutdown.cmd" 
 
-call "%APP_HOME%\bin\start.bat" 
+call "%APP_HOME%\bin\start.cmd" 

conf/application.xml

@@ -1,15 +1,14 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
-<application nodeid="10000" port="2121">     
-    
-    <!--  详细配置说明见： http://redkale.org/redkale.html#redkale_confxml  -->
+<application nodeid="10000" port="2020">     
         
     <resources>  
-
+        <properties load="config.properties">
+            <property name="system.property.redkale.convert.protobuf.enumtostring" value="true"/>
+        </properties>         
     </resources> 
         
-    <server protocol="HTTP" port="6060">      
-              
+    <server protocol="HTTP" port="5050">                    
         <request>
             <remoteaddr value="request.headers.X-RemoteAddress"/>
         </request>
@@ -24,10 +23,9 @@
         
         <filters autoload="true"/>
 
-        <rest path="/pipes" />  <!-- base指定的自定义HttpServlet子类必须标记@HttpUserType, 不设置base则视为没有当前用户信息设置  -->  
+        <rest path="/pipes" /> 
         
         <servlets path="/pipes" autoload="true" />        
-        
     </server>
     
 </application>

conf/config.properties

@@ -0,0 +1,2 @@
+
+#

conf/logging.properties

@@ -18,8 +18,8 @@ java.util.logging.FileHandler.level = FINER
 java.util.logging.FileHandler.limit = 10M
 java.util.logging.FileHandler.count = 20
 java.util.logging.FileHandler.encoding = UTF-8
-java.util.logging.FileHandler.pattern = ${APP_HOME}/logs-%m/log-%d.log
-java.util.logging.FileHandler.unusual = ${APP_HOME}/logs-%m/log-warnerr-%d.log
+java.util.logging.FileHandler.pattern = ${APP_HOME}/logs-%tY%tm/log-%tY%tm%td.log
+java.util.logging.FileHandler.unusual = ${APP_HOME}/logs-%tY%tm/log-warnerr-%tY%tm%td.log
 java.util.logging.FileHandler.append = true
 
 java.util.logging.ConsoleHandler.level = FINEST

conf/persistence.xml

@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
-    
-    <persistence-unit name="" transaction-type="RESOURCE_LOCAL">
-        <shared-cache-mode>ALL</shared-cache-mode>
-        <properties>
-            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/center?autoReconnect=true&amp;characterEncoding=utf8"/>
-            <property name="javax.persistence.jdbc.user" value="root"/>
-            <property name="javax.persistence.jdbc.password" value="1234"/>
-        </properties>
-    </persistence-unit>
-    
-    <!--
-    <persistence-unit name="user.read" transaction-type="RESOURCE_LOCAL">
-        <shared-cache-mode>ALL</shared-cache-mode>
-        <properties>
-            <property name="javax.persistence.jdbc.url" value="jdbc:oracle:thin:@localhost:1521:orcl"/>
-            <property name="javax.persistence.jdbc.user" value="system"/>
-            <property name="javax.persistence.jdbc.password" value="1234"/>
-        </properties>
-    </persistence-unit>
-    
-    <persistence-unit name="user.write" transaction-type="RESOURCE_LOCAL">
-        <shared-cache-mode>ALL</shared-cache-mode>
-        <properties>
-            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/center?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&rewriteBatchedStatements=true"/>
-            <property name="javax.persistence.jdbc.user" value="root"/>
-            <property name="javax.persistence.jdbc.password" value="1234"/>
-        </properties>
-    </persistence-unit>
-    -->
-    
-</persistence>

conf/source.properties

@@ -0,0 +1,13 @@
+
+############ DataSource   @Resource(name="platf") ############
+#redkale.datasource[platf].url = jdbc:mysql://127.0.0.1:3306/platf?allowPublicKeyRetrieval=true&rewriteBatchedStatements=true&serverTimezone=UTC&characterEncoding=utf8
+#redkale.datasource[platf].user = root
+#redkale.datasource[platf].password = 12345678
+### true: auto ddl;
+#redkale.datasource[platf].table-autoddl = true 
+
+
+############ CacheSource   @Resource(name="usersession") ############
+#redkale.cachesource[usersession].node[0].url = redis://127.0.0.1:6363
+#redkale.cachesource[usersession].node[0].password = 12345678
+#redkale.cachesource[usersession].node[0].db = 0

my/gitrun.sh

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+export LC_ALL="zh_CN.UTF-8"
+
+rm -fr redkale
+
+rm -fr src
+rm -fr bin
+rm -fr conf
+
+git clone https://github.com/redkale/redkale.git
+
+cp -fr redkale/src ./
+cp -fr redkale/bin ./
+cp -fr redkale/conf ./
+
+mvn clean
+mvn deploy

my/pom.xml

@@ -4,13 +4,37 @@
     <groupId>org.redkale</groupId>
     <artifactId>redkale</artifactId>
     <packaging>jar</packaging>
+    <name>RedkaleProject</name>     
     <url>http://redkale.org</url>
     <description>redkale -- java framework</description>
-    <version>2.2.0</version>
+    <version>2.7.0-SNAPSHOT</version>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>11</maven.compiler.source>
+        <maven.compiler.target>11</maven.compiler.target>
+		
+        <junit.version>5.7.0</junit.version> 
+        <maven-plugin.version>3.2.0</maven-plugin.version>
+        <maven-gpg-plugin.version>3.0.1</maven-gpg-plugin.version>
+        <maven-compiler-plugin.version>3.8.0</maven-compiler-plugin.version>
+        <maven-surefire-plugin.version>3.0.0-M5</maven-surefire-plugin.version>
+        <maven-failsafe-plugin.version>3.0.0-M5</maven-failsafe-plugin.version>
+    </properties>
+    
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
     <licenses>     
         <license>      
             <name>Apache 2</name>       
-            <url>http://www.apache.org/licenses/</url>     
+            <url>https://www.apache.org/licenses/</url>     
             <distribution>repo</distribution>    
             <comments>Apache License</comments>     
         </license>      
@@ -21,13 +45,13 @@
             <id>Redkale</id>     
             <name>redkale</name>       
             <email>redkale@qq.com</email>  
-            <url>http://redkale.org</url>    
+            <url>https://redkale.org</url>    
             <roles>     
                 <role>Project Manager</role>     
                 <role>Architect</role>     
             </roles>    
             <organization>redkale</organization>     
-            <organizationUrl>http://redkale.org</organizationUrl>       
+            <organizationUrl>https://redkale.org</organizationUrl>       
             <properties>     
                 <dept>No</dept>     
             </properties>     
@@ -35,12 +59,6 @@
         </developer>     
     </developers>  
     
-    <properties>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <maven.compiler.source>11</maven.compiler.source>
-        <maven.compiler.target>11</maven.compiler.target>
-    </properties>
-    <name>Redkale</name>
     <distributionManagement>
         <snapshotRepository>
             <id>ossrh</id>
@@ -51,17 +69,19 @@
             <url>https://oss.sonatype.org/service/local/staging/deploy/maven2/</url>
         </repository>
     </distributionManagement>
+
     <scm>
         <url>https://github.com/redkale/redkale</url>
         <connection>scm:git:git@github.com/redkale/redkale.git</connection>
         <developerConnection>scm:git:git@github.com:redkale/redkale.git</developerConnection>
     </scm>
+
     <build>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.8.0</version>                                
+                <version>${maven-compiler-plugin.version}</version>                                
                 <configuration>
 					<compilerArgument>-parameters</compilerArgument>
                     <encoding>UTF-8</encoding>
@@ -74,7 +94,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-jar-plugin</artifactId>
-                <version>3.2.0</version>
+                <version>${maven-plugin.version}</version>
                 <configuration>
                     <archive>
 						<addMavenDescriptor>false</addMavenDescriptor>
@@ -88,7 +108,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-gpg-plugin</artifactId>
-                <version>1.6</version>
+                <version>${maven-gpg-plugin.version}</version>
                 <executions>
                     <execution>
                         <id>sign-artifacts</id>
@@ -99,10 +119,11 @@
                     </execution>
                 </executions>
             </plugin>
+
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-source-plugin</artifactId>
-                <version>3.2.0</version>
+                <version>${maven-plugin.version}</version>
                 <executions>
                     <execution>
                         <goals>
@@ -111,10 +132,11 @@
                     </execution>
                 </executions>
             </plugin>
+
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-javadoc-plugin</artifactId>
-                <version>3.2.0</version>
+                <version>${maven-plugin.version}</version>
                 <executions>
                     <execution>
                         <goals>
@@ -127,7 +149,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-assembly-plugin</artifactId>   
-                <version>3.2.0</version>
+                <version>${maven-plugin.version}</version>
                 <configuration>
                     <appendAssemblyId>false</appendAssemblyId>
                     <descriptors>   

my/readme.txt

@@ -1 +1,9 @@
 <EFBFBD><EFBFBD>Ŀ¼<EFBFBD>µ<EFBFBD><EFBFBD>ļ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>sonatypeʱʹ<EFBFBD>ã<EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڹ<EFBFBD><DAB9>̴<EFBFBD><CCB4><EFBFBD><EFBFBD><EFBFBD>
+
+ʹ<EFBFBD><EFBFBD>gpg<EFBFBD><EFBFBD><EFBFBD><EFBFBD>sonatype<EFBFBD><EFBFBD>Կ:
+
+1<EFBFBD><EFBFBD> gpg  <20>C-gen-key
+2<EFBFBD><EFBFBD> gpg --keyserver keys.openpgp.org --send-keys  <20><><EFBFBD>Ĺ<EFBFBD>Կ(һ<><D2BB>ʮ<EFBFBD><CAAE><EFBFBD><EFBFBD><EFBFBD>Ƶ<EFBFBD><C6B5><EFBFBD><EFBFBD>֣<EFBFBD><D6A3><EFBFBD><EFBFBD><EFBFBD>DE346FA5)
+      <20><>ʾ<EFBFBD><CABE> gpg: <20>ӹ<EFBFBD>Կ<EFBFBD><D4BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD>ܣ<EFBFBD>Server indicated a failure  <20><>ʾ<EFBFBD><CABE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+  

my/settings.xml

@@ -21,6 +21,7 @@
         
         <profile> 
             <id>release</id>
+			<!--
             <build>
                 <plugins>
                     <plugin>
@@ -92,6 +93,7 @@
                     </plugin>
                 </plugins>
             </build>
+			-->
         </profile>
     </profiles>
 </settings>

pom.xml

@@ -0,0 +1,142 @@
+<?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">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>org.redkale</groupId>
+    <artifactId>redkale</artifactId>
+    <packaging>jar</packaging>
+    <name>RedkaleProject</name>     
+    <url>https://redkale.org</url>
+    <description>redkale -- java framework</description>
+    <version>2.7.0</version>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>11</maven.compiler.source>
+        <maven.compiler.target>11</maven.compiler.target>
+        
+        <junit.version>5.7.0</junit.version>
+        <maven-jar-plugin.version>3.2.2</maven-jar-plugin.version>
+        <maven-compiler-plugin.version>3.9.0</maven-compiler-plugin.version>
+        <maven-surefire-plugin.version>3.0.0-M6</maven-surefire-plugin.version>
+        <maven-failsafe-plugin.version>3.0.0-M6</maven-failsafe-plugin.version>
+    </properties>
+
+    <licenses>     
+        <license>      
+            <name>Apache 2</name>       
+            <url>https://www.apache.org/licenses/</url>     
+            <distribution>repo</distribution>    
+            <comments>Apache License</comments>     
+        </license>      
+    </licenses>
+    
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>${junit.version}</version>
+            <scope>test</scope>
+        </dependency>        
+    </dependencies>
+    
+    <repositories>
+        <repository>
+            <id>central</id>
+            <name>Central Repository</name>
+            <url>https://repo.maven.apache.org/maven2</url>
+        </repository>
+        <repository>
+            <id>sonatype-nexus-snapshots</id>
+            <name>Sonatype Nexus Snapshots</name>
+            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+        </repository>
+    </repositories>
+    
+    <developers>     
+        <developer>      
+            <id>Redkale</id>     
+            <name>redkale</name>       
+            <email>redkale@qq.com</email>  
+            <url>https://redkale.org</url>    
+            <roles>     
+                <role>Project Manager</role>     
+                <role>Architect</role>     
+            </roles>    
+            <organization>redkale</organization>     
+            <organizationUrl>https://redkale.org</organizationUrl>       
+            <properties>     
+                <dept>No</dept>     
+            </properties>     
+            <timezone>8</timezone>     
+        </developer>     
+    </developers>  
+
+    <scm>
+        <url>https://github.com/redkale/redkale</url>
+        <connection>scm:git:git@github.com/redkale/redkale.git</connection>
+        <developerConnection>scm:git:git@github.com:redkale/redkale.git</developerConnection>
+    </scm>
+
+    <build>
+        <plugins>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>                                               
+                <configuration>				
+                    <encoding>UTF-8</encoding>
+                    <compilerArgs>
+                        <arg>-parameters</arg>
+                    </compilerArgs>
+                </configuration>
+            </plugin>
+            <!--  需要注释掉， 否则会生成native-image配置信息
+            <plugin>
+                <groupId>org.redkale.maven.plugins</groupId>
+                <artifactId>redkale-maven-plugin</artifactId>
+                <version>1.1.0</version>                                                
+                <executions>
+                    <execution>
+                        <id>redkale-compile</id> 
+                        <phase>process-classes</phase>
+                        <goals>
+                            <goal>compile</goal>
+                        </goals>                   
+                    </execution>
+                </executions>    
+            </plugin>
+            -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>${maven-jar-plugin.version}</version>
+                <configuration>
+                    <archive>
+                        <addMavenDescriptor>false</addMavenDescriptor>
+                        <manifest>
+                            <mainClass>org.redkale.boot.Application</mainClass>
+                        </manifest>
+                    </archive>
+                </configuration>
+            </plugin>
+                    
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${maven-surefire-plugin.version}</version>
+                <configuration>
+                    <forkMode>once</forkMode>
+                    <argLine>-Dfile.encoding=UTF-8</argLine>
+                </configuration>
+            </plugin>
+        
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-failsafe-plugin</artifactId>
+                <version>${maven-failsafe-plugin.version}</version>
+            </plugin>
+        </plugins>
+    </build>
+    
+</project>

root/readme.txt

@@ -0,0 +1 @@
+ 

src/javax/annotation/Resource.java

@@ -1,32 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package javax.annotation;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-/**
- * @since Common Annotations 1.0
- */
-@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Resource {
-    public enum AuthenticationType {
-        CONTAINER,
-        APPLICATION
-    }
-    public String name() default "";
-
-    public Class<?> type() default Object.class;
-    public AuthenticationType authenticationType() default AuthenticationType.CONTAINER;
-    public boolean shareable() default true;
-    public String description() default "";
-    public String mappedName() default "";
-
-    public String lookup() default "";
-}

src/main/java/META-INF/apidoc-template.html

@@ -55,8 +55,8 @@
                                 } else {
                                     var w = param.required ? "font-weight:bold;" : "";
                                     var c = ' style="' + w + '"';
-                                    if (param.src == "HEADER") c = ' style="color:red;' + w + '"';
-                                    if (param.src == "COOKIE") c = ' style="color:blue;' + w + '"';
+                                    if (param.style == "HEADER") c = ' style="color:red;' + w + '"';
+                                    if (param.style == "COOKIE") c = ' style="color:blue;' + w + '"';
                                     paramshtml.push('<tr><td ' + c + '> ' + param.name + ' </td><td> ' + t + '</td><td> ' + param.comment + '</td></tr>');
                                 }
                             }

src/main/java/META-INF/application-template.properties

@@ -0,0 +1,51 @@
+
+redkale.nodeid = 1000
+redkale.port = 6560
+redkale.lib = ./
+
+#\u3010resources\u8282\u70b9\u5168\u5c40\u552f\u4e00\u3011
+#\u3010executor\u8282\u70b9\u5168\u5c40\u552f\u4e00\u3011
+redkale.resources.executor.threads = 4
+redkale.resources.executor.hash = false
+
+#\u3010transport\u8282\u70b9\u5168\u5c40\u552f\u4e00\u3011
+redkale.resources.transport.bufferCapacity = 32k
+redkale.resources.transport.bufferPoolSize = 32
+
+#\u3010excludelibs\u8282\u70b9\u5168\u5c40\u552f\u4e00\u3011
+redkale.resources.excludelibs.value = ^.*mysql.*$;^.*kafka.*$
+
+#\u3010cluster\u8282\u70b9\u5168\u5c40\u552f\u4e00\u3011
+redkale.resources.cluster.type = org.redkalex.cluster.consul.ConsulClusterAgent
+redkale.resources.cluster.waits= = false
+redkale.resources.cluster.protocols = SNCP
+redkale.resources.cluster.ports = 7070;7071
+
+redkale.resources.mq[0].name = 
+redkale.resources.mq[0].type = org.redkalex.mq.kafka.KafkaMessageAgent
+redkale.resources.mq[0].servers.value = 127.0.0.1:9101
+
+redkale.resources.group[0].name = 
+redkale.resources.group[0].protocol = TCP
+redkale.resources.group[0].node[0].addr = 127.0.0.1
+redkale.resources.group[0].node[0].port = 7070
+
+#\u3010listener\u8282\u70b9\u5168\u5c40\u552f\u4e00\u3011
+redkale.resources.listener.value = org.redkalex.xxx.XXXApplicationListener
+
+#\u3010properties\u8282\u70b9\u5168\u5c40\u552f\u4e00\u3011
+redkale.resources.properties.load = config.properties
+redkale.resources.properties.property[0].name = system.property.yyyy
+redkale.resources.properties.property[0].value = YYYYYY
+redkale.resources.properties.property[1].name = xxxxxxx
+redkale.resources.properties.property[1].value = YYYYYY
+
+redkale.server[0].protocol = HTTP
+redkale.server[0].host = 127.0.0.1
+redkale.server[0].port = 6060
+redkale.server[0].root = root
+redkale.server[0].lib = 
+#\u3010\u8282\u70b9\u5728<server>\u4e2d\u552f\u4e00\u3011
+redkale.server[0].ssl.build = org.redkale.net.SSLBuilder\u5b50\u7c7b
+
+redkale.server[0].services[0].autoload = true

src/main/java/META-INF/application-template.xml

@@ -20,7 +20,7 @@
 -->
 <!--     
     nodeid: int     进程的节点ID，用于分布式环境，一个系统中节点ID必须全局唯一，使用cluster时框架会进行唯一性校验
-    name:           进程的名称，用于监控识别，命名规则: 字母、数字、下划线
+    name:           进程的名称，用于监控识别，命名规则: 字母、数字、下划线、短横、点
     address:        本地局域网的IP地址， 默认值为默认网卡的ip，当不使用默认值需要指定值，如192.168.1.22
     port: required  程序的管理Server的端口，用于关闭或者与监管系统进行数据交互
     lib:            加上额外的lib路径,多个路径用分号;隔开； 默认为空。  例如: ${APP_HOME}/lib/a.jar;${APP_HOME}/lib2/b.jar;
@@ -33,6 +33,14 @@
     -->
     <resources>  
         
+        <!--
+           【节点全局唯一】 @since 2.3.0
+            全局Serivce执行的线程池， Application.workExecutor, 没配置该节点将自动创建一个。
+            threads： 线程数，为0表示不启用workExecutor，只用IO线程。默认: CPU核数, 核数=1的情况下默认值为2
+            hash:     是否使用ThreadHashExecutor作为线程池，默认值为：false
+        -->
+        <executor threads="4" hash="false"/>
+        
         <!--
             【节点全局唯一】
             transport节点只能有一个，用于配置所有Transport的池参数，没配置该节点将自动创建一个。
@@ -55,29 +63,29 @@
         <!--
            【节点全局唯一】
             第三方服务发现管理接口
-            value：    类名，必须是org.redkale.cluster.ClusterAgent的子类
-            waits:     注销服务后是否需要等待检查周期时间后再进行Service销毁，默认值为：false
-                       当一个Service进行服务注销后，不能立刻销毁Service，因为健康检测是有间隔时间差的，
-                       需要等待一个健康检测周期时间，让其他进程都更新完服务列表。
-                       如果使用MQ，可以设置为false，如果对服务健壮性要求高，建议设置为true
-            protocols: 服务发现可以处理的协议， 默认值为: SNCP, 多个协议用分号;隔开
-            ports:     服务发现可以处理的端口， 多个端口用分号;隔开
-        -->
-        <!--
-        <cluster value="org.redkalex.cluster.consul.ConsulClusterAgent" waits="false" protocols="SNCP" ports="7070;7071">
-            <property name="xxxxxx" value="XXXXXXXX"/>
-        </cluster>
+            type：          类名，必须是org.redkale.cluster.ClusterAgent的子类
+            waits:          注销服务后是否需要等待检查周期时间后再进行Service销毁，默认值为：false
+                            当一个Service进行服务注销后，不能立刻销毁Service，因为健康检测是有间隔时间差的，
+                            需要等待一个健康检测周期时间，让其他进程都更新完服务列表。
+                            如果使用MQ，可以设置为false，如果对服务健壮性要求高，建议设置为true
+            protocols:      服务发现可以处理的协议， 默认值为: SNCP, 多个协议用分号;隔开
+            ports:          服务发现可以处理的端口， 多个端口用分号;隔开
+            ttls:           心跳频率，多少秒一次
+            xxxx:           自定义的字段属性，例如：CacheClusterAgent有source字段; ConsulClusterAgent有apiurl字段;
         -->
+        <cluster type="org.redkalex.cluster.consul.ConsulClusterAgent" waits="false" protocols="SNCP" ports="7070;7071" xxx="xxx" />
+
         <!--
             MQ管理接口配置
             不同MQ节点所配置的MQ集群不能重复。
             MQ跟着协议走，所以mq的属性值需要被赋值在rest节点上, 由于SncpServlet是自动生成的，故SNCP协议下，mq属性值被赋值在service/services节点上
             name:   服务的名称，用于监控识别，多个mq节点时只能有一个name为空的节点，mq.name不能重复,命名规则: 字母、数字、下划线
-            value： 实现类名，必须是org.redkale.mq.MessageAgent的子类
+            type： 实现类名，必须是org.redkale.mq.MessageAgent的子类
+            coder: MessageRecord的解析器类，必须是org.redkale.mq.MessageCoder<MessageRecord>的实现类, 
+                   可对数据包进行加密解密，默认值：org.redkale.mq.MessageRecordCoder
             MQ节点下的子节点配置没有固定格式, 根据MessageAgent实现方的定义来配置
         -->
-        <!--
-        <mq name="" value="org.redkalex.mq.kafka.KafkaMessageAgent">
+        <mq name="" type="org.redkalex.mq.kafka.KafkaMessageAgent">
             <servers value="127.0.0.1:9101"/>
             <consumer>
                 <property name="xxxxxx" value="XXXXXXXX"/>
@@ -86,7 +94,7 @@
                 <property name="xxxxxx" value="XXXXXXXX"/>
             </producer>
         </mq>
-        -->
+        
         <!--
             一个组包含多个node， 同一Service服务可以由多个进程提供，这些进程称为一个GROUP，且同一GROUP内的进程必须在同一机房或局域网内
             一个group节点对应一个 Transport 对象。
@@ -104,17 +112,6 @@
             <node addr="127.0.0.1" port="7070"/>
         </group>
 
-        <!--
-            全局的数据源设置, 可以是CacheSource、DataSource， JDBC的DataSource通常通过persistence.xml配置，此处多用于CacheSource的配置
-            name:    资源名，用于依赖注入。
-            value：  类名，必须是CacheSource或DataSource的子类，且必须实现Service接口。如果是DataSource.class，系统自动映射成DataJdbcSource.class
-            groups:  指定groups。
-            xxx:     其他属性与子节点通过Service.init方法传入的AnyValue获取。
-        -->
-        <source name="redis" value="org.redkalex.cache.RedisCacheSource" xxx="16">
-            <node addr="127.0.0.1" port="7070"/>
-        </source>
-        
         <!--
            Application启动的监听事件,可配置多个节点
            value: 类名，必须是ApplicationListener的子类
@@ -126,19 +123,21 @@
             全局的参数配置, 可以通过@Resource(name="property.xxxxxx") 进行注入<property>的信息, 被注解的字段类型只能是String、primitive class
             如果name是system.property.开头的值将会在进程启动时进行System.setProperty("yyyy", "YYYYYY")操作。
             如果name是mimetype.property.开头的值将会在进程启动时进行MimeType.add("yyyy", "YYYYYY")操作。
+            先加载子节点property，再加载load文件， 最后加载agent的实现子类。
+            agent: 实现类名，必须是org.redkale.boot.PropertiesAgent的子类
             load:  加载文件，多个用;隔开。
             默认置入的system.property.的有：
-               System.setProperty("net.transport.poolmaxconns", "100");
-               System.setProperty("net.transport.pinginterval", "30");
-               System.setProperty("net.transport.checkinterval", "30");
-               System.setProperty("convert.tiny", "true");
-               System.setProperty("convert.pool.size", "128");
-               System.setProperty("convert.writer.buffer.defsize", "4096");
+               System.setProperty("redkale.net.transport.poolmaxconns", "100");
+               System.setProperty("redkale.net.transport.pinginterval", "30");
+               System.setProperty("redkale.net.transport.checkinterval", "30");
+               System.setProperty("redkale.convert.tiny", "true");
+               System.setProperty("redkale.convert.pool.size", "128");
+               System.setProperty("redkale.convert.writer.buffer.defsize", "4096");
                
             <properties>节点下也可包含非<property>节点.
             非<property>其节点可以通过@Resource(name="properties.xxxxxx")进行注入, 被注解的字段类型只能是AnyValue、AnyValue[]
         -->
-        <properties load="config.properties">
+        <properties load="config.properties" agent="">
             <property name="system.property.yyyy" value="YYYYYY"/>
             <property name="xxxxxx" value="XXXXXXXX"/>
             <property name="xxxxxx" value="XXXXXXXX"/>
@@ -156,30 +155,38 @@
         excludelibs:         排除lib.path与excludes中的正则表达式匹配的路径, 多个正则表达式用分号;隔开
         charset:             文本编码， 默认: UTF-8
         backlog:             默认10K
-        threads：            线程数， 默认: CPU核数*2，最小8个
+        threads【已废弃】：    线程数， 默认: CPU核数*2，最小8个【已废弃 @since 2.3.0】
         maxconns：           最大连接数, 小于1表示无限制， 默认: 0
         maxbody:             request.body最大值， 默认: 64K
         bufferCapacity:      ByteBuffer的初始化大小， TCP默认: 32K;  (HTTP 2.0、WebSocket，必须要16k以上); UDP默认: 1350B
         bufferPoolSize：     ByteBuffer池的大小，默认: 线程数*4
-        responsePoolSize：   Response池的大小，默认: 线程数*2
+        responsePoolSize：   Response池的大小，默认: 1024
         aliveTimeoutSeconds: KeepAlive读操作超时秒数， 默认30， 0表示永久不超时; -1表示禁止KeepAlive
         readTimeoutSeconds:  读操作超时秒数， 默认0， 表示永久不超时
         writeTimeoutSeconds: 写操作超时秒数， 默认0， 表示永久不超时
-        netimpl:             ProtocolServer的实现类。TCP情况下值可以是aio或nio，默认值为aio；UDP情况下值可以是bio，默认值为bio；
         interceptor:         启动/关闭NodeServer时被调用的拦截器实现类，必须是org.redkale.boot.NodeInterceptor的子类，默认为null
     -->
     <server protocol="HTTP" host="127.0.0.1" port="6060" root="root" lib=""> 
         
         <!-- 
            【节点在<server>中唯一】
-           value: 创建SSLContext的实现类, 可自定义，必须是org.redkale.net.SSLCreator的子类
-           clientauth:     true/false/want
-           keystorepass:   KEY密码
-           keystorefile:   KEY文件
-           truststorepass: TRUST密码
-           truststorefile: TRUST文件
+           builder:             创建SSLContext的实现类, 可自定义，必须是org.redkale.net.SSLBuilder的子类
+           sslProvider:         java.security.Provider自定义的实现类，如第三方: org.conscrypt.OpenSSLProvider、org.bouncycastle.jce.provider.BouncyCastleProvider
+           jsseProvider:        java.security.Provider自定义的实现类，如第三方: org.conscrypt.JSSEProvider、   org.bouncycastle.jce.provider.BouncyCastleJsseProvider
+           protocol:            TLS版本，默认值: TLS
+           protocols:           设置setEnabledProtocols, 多个用,隔开 如: TLSv1.2,TLSv1.3
+           clientAuth:          WANT/NEED/NONE, 默认值: NONE
+           ciphers:             设置setEnabledCipherSuites, 多个用,隔开 如: TLS_RSA_WITH_AES_128_CBC_SHA256,TLS_RSA_WITH_AES_256_CBC_SHA256
+           keystorePass:        KEY密码
+           keystoreFile:        KEY文件 .jks
+           keystoreType:        KEY类型， 默认值为JKS
+           keystoreAlgorithm:   KEY文件的algorithm， 默认值为SunX509
+           truststorePass:      TRUST密码
+           truststoreFile:      TRUST文件
+           truststoreType:      TRUST类型， 默认值为JKS
+           truststoreAlgorithm: TRUST文件的algorithm， 默认值为SunX509
         -->
-        <ssl creator=""/>
+        <ssl builder=""/>
         
         <!-- 
            加载所有的Service服务;
@@ -266,10 +273,13 @@
            当Server为HTTP协议时, request节点才有效。
            remoteaddr 节点: 替换请求方节点的IP地址， 通常请求方是由nginx等web静态服务器转发过的则需要配置该节点。
            且value值只能是以request.headers.开头，表示从request.headers中获取对应的header值。
+           locale value值必须是request.headers.或request.parameters.开头。
            例如下面例子获取request.getRemoteAddr()值，如果header存在X-RemoteAddress值则返回X-RemoteAddress值，不存在返回getRemoteAddress()。
         -->
         <request>
             <remoteaddr value="request.headers.X-RemoteAddress"/>
+            <locale value="request.headers.locale" /> 
+            <rpc authenticator="org.redkale.net.http.HttpRpcAuthenticator的实现类"/>
         </request>
         
         <!--
@@ -278,8 +288,8 @@
            contenttype: plain值为调用finish时的ContentType; 默认值: text/plain; charset=utf-8
                         json值为调用finishJson时的ContentType; 默认值: application/json; charset=utf-8
            defcookie 节点: 当response里输出的cookie没有指定domain 和path时，使用该节点的默认值。
-           如果addheader、setheader 的value值以request.parameters.开头则表示从request.parameters中获取对应的parameter值
-           如果addheader、setheader 的value值以request.headers.开头则表示从request.headers中获取对应的header值
+           addheader、setheader 的value值以request.parameters.开头则表示从request.parameters中获取对应的parameter值
+           addheader、setheader 的value值以request.headers.开头则表示从request.headers中获取对应的header值
            例如下面例子是在Response输出header时添加两个header（一个addHeader， 一个setHeader）。
            options 节点: 设置了该节点且auto=true，当request的method=OPTIONS自动设置addheader、setheader并返回200状态码
            date 节点: 设置了该节点且period有值(单位：毫秒);返回response会包含Date头信息，默认为period=0
@@ -288,7 +298,7 @@
                       period>0表示定时获取时间; 设置1000表示每秒刷新Date时间
         -->
         <response>
-            <contenttype plain="text/plain; charset=utf-8" json="application/json; charset=utf-8"/>            
+            <content-type plain="text/plain; charset=utf-8" json="application/json; charset=utf-8"/>            
             <defcookie domain="" path=""/>  
             <addheader name="Access-Control-Allow-Origin" value="request.headers.Origin" /> 
             <setheader name="Access-Control-Allow-Headers" value="request.headers.Access-Control-Request-Headers"/>
@@ -300,8 +310,9 @@
            【节点在<server>中唯一】
            当Server为HTTP协议时，render才有效. 指定输出引擎的实现类
            value: 输出引擎的实现类, 必须是org.redkale.net.http.HttpRender的子类
+           suffixs: 引擎文件名后缀，多个用;隔开，默认值为: .htel
         -->
-        <render value="org.redkalex.htel.HttpTemplateRender"/>
+        <render value="org.redkalex.htel.HttpTemplateRender" suffixs=".htel"/>
         <!-- 
            【节点在<server>中唯一】
            当Server为HTTP协议时，ResourceServlet才有效. 默认存在一个有默认属性的resource-servlet节点

src/main/java/META-INF/logging-template.properties

@@ -15,11 +15,16 @@ com.sun.level = INFO
 java.util.logging.FileHandler.limit = 20M
 java.util.logging.FileHandler.count = 100
 java.util.logging.FileHandler.encoding = UTF-8
-java.util.logging.FileHandler.pattern = ${APP_HOME}/logs-%m/log-%d.log
+java.util.logging.FileHandler.pattern = ${APP_HOME}/logs-%tY%tm/log-%tY%tm%td.log
 #java.util.logging.FileHandler.unusual \u5c5e\u6027\u8868\u793a\u5c06 WARNING\u3001SEVERE \u7ea7\u522b\u7684\u65e5\u5fd7\u590d\u5236\u5199\u5165\u5355\u72ec\u7684\u6587\u4ef6\u4e2d
-java.util.logging.FileHandler.unusual = ${APP_HOME}/logs-%m/log-warnerr-%d.log
+java.util.logging.FileHandler.unusual = ${APP_HOME}/logs-%tY%tm/log-warnerr-%tY%tm%td.log
 #\u9700\u8981\u5c4f\u853d\u6d88\u606f\u5185\u5bb9\u7684\u6b63\u5219\u8868\u8fbe\u5f0f
 java.util.logging.FileHandler.denyreg = 
 java.util.logging.FileHandler.append = true
 
 #java.util.logging.ConsoleHandler.level = FINE
+
+#\u5c06\u65e5\u5fd7\u5199\u8fdbSearchSource, \u5fc5\u987b\u6307\u5b9asource\u8d44\u6e90\u540d\uff0c\u5728source.properties\u4e2d\u5b9a\u4e49
+#java.util.logging.SearchHandler.source = platfsearch
+#\u6307\u5b9a\u5199\u8fdbSearchSource\u7684\u8868\u540d\uff0c\u9ed8\u8ba4\u503c\u4e3alog-record
+#java.util.logging.SearchHandler.tag = log-${APP_NAME}-%tY%tm%td

src/main/java/META-INF/persistence-template.xml

@@ -1,5 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- 其配置算是标准的JPA配置文件的缩略版 -->
+<!-- 
+  【已废弃】，建议使用 source.properties
+   其配置算是标准的JPA配置文件的缩略版
+-->
 <persistence>	
     <!-- 系统基本库 -->
     <persistence-unit name="demouser">
@@ -12,28 +15,18 @@
                 是否开启缓存(标记为@Cacheable的Entity类)，值目前只支持两种： ALL: 所有开启缓存。 NONE: 关闭所有缓存， 非NONE字样统一视为ALL
             -->
             <property name="javax.persistence.cachemode" value="ALL"/>
-            
-            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://127.0.0.1:3306/dbuser?characterEncoding=utf8"/>
             <!-- 
-                javax.persistence.jdbc.driver在JPA的值是JDBC驱动，Redkale有所不同，值应该是javax.sql.DataSource的子类。 
-                为了兼容用户习惯，Redkale内置常见JDBC驱动到javax.sql.DataSource的映射关系：
-                                     org.mariadb.jdbc.Driver  ——————  org.mariadb.jdbc.MySQLDataSource
-                                       org.postgresql.Driver  ——————  org.postgresql.ds.PGConnectionPoolDataSource
-                                       com.mysql.jdbc.Driver  ——————  com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource
-                                    com.mysql.cj.jdbc.Driver  ——————  com.mysql.cj.jdbc.MysqlConnectionPoolDataSource
-                             oracle.jdbc.driver.OracleDriver  ——————  oracle.jdbc.pool.OracleConnectionPoolDataSource
-                com.microsoft.sqlserver.jdbc.SQLServerDriver  ——————  com.microsoft.sqlserver.jdbc.SQLServerConnectionPoolDataSource
-                                               org.h2.Driver  ——————  org.h2.jdbcx.JdbcDataSource
-                因此 com.mysql.jdbc.Driver 会被自动转换成 com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource
-                并且如果JDBC驱动是以上几个版本，javax.persistence.jdbc.driver属性都可以省略，Redkale会根据javax.persistence.jdbc.url的值来识别驱动
-            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
-            <property name="javax.persistence.jdbc.source" value="com.mysql.jdbc.jdbc2.optional.MysqlConnectionPoolDataSource"/>
+                是否自动建表当表不存在的时候， 目前只支持mysql、postgres， 默认为false
             -->
+            <property name="javax.persistence.table.autoddl" value="false"/>
+            
+            <!-- 多个URL用;隔开，如分布式SearchSource需要配多个URL -->
+            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://127.0.0.1:3306/dbuser?characterEncoding=utf8"/>
             <property name="javax.persistence.jdbc.user" value="root"/>
             <property name="javax.persistence.jdbc.password" value="123456"/>
             
-            <!-- 最大连接数，默认值：CPU数*16  -->
-            <property name="javax.persistence.connections.limit" value="32"/>
+            <!-- 最大连接数，默认值：CPU数 -->
+            <property name="javax.persistence.connections.limit" value="12"/>
             
             <!--  包含的SQL模板，相当于反向LIKE，不同的JDBC驱动的SQL语句不一样，Redkale内置了MySQL的语句 -->
             <property name="javax.persistence.contain.sqltemplate" value="LOCATE(${keystr}, ${column}) > 0"/>
@@ -41,14 +34,14 @@
             
             <!--  复制表结构的SQL模板，Redkale内置了MySQL的语句 -->
             <property name="javax.persistence.tablenotexist.sqlstates" value="42000;42S02"/>
-            <property name="javax.persistence.tablecopy.sqltemplate" value="CREATE TABLE ${newtable} LIKE ${oldtable}"/>
+            <property name="javax.persistence.tablecopy.sqltemplate" value="CREATE TABLE IF NOT EXISTS ${newtable} LIKE ${oldtable}"/>
            
         </properties>
     </persistence-unit>
     <!-- IM消息库 -->
     <persistence-unit name="demoim">
         <properties>
-            <!-- jdbc:mysql://127.0.0.1:3306/dbim?autoReconnect=true&amp;autoReconnectForPools=true&amp;characterEncoding=utf8 -->
+            <!-- jdbc:mysql://127.0.0.1:3306/dbim?allowPublicKeyRetrieval=true&amp;rewriteBatchedStatements=true&amp;serverTimezone=UTC&amp;characterEncoding=utf8 -->
             <property name="javax.persistence.jdbc.url" value="jdbc:mysql://127.0.0.1:3306/dbim?characterEncoding=utf8"/>
             <property name="javax.persistence.jdbc.user" value="root"/>
             <property name="javax.persistence.jdbc.password" value="123456"/>

src/main/java/META-INF/source-template.properties

@@ -0,0 +1,50 @@
+
+# CacheSource   @Resource(name="usersession")
+# type\u53ef\u4ee5\u4e0d\u7528\u8bbe\u7f6e\uff0c\u6846\u67b6\u4f1a\u6839\u636eurl\u5224\u65ad\u4f7f\u7528\u54ea\u4e2aCacheSource\u5b9e\u73b0\u7c7b
+redkale.cachesource[usersession].type = org.redkalex.cache.redis.RedisCacheSource
+# \u6700\u5927\u8fde\u63a5\u6570
+redkale.cachesource[usersession].maxconns = 16
+# \u8282\u70b9\u5730\u5740
+redkale.cachesource[usersession].node[0].url = redis://127.0.0.1:6363
+# \u8282\u70b9\u5bc6\u7801
+redkale.cachesource[usersession].node[0].password = 12345678
+# \u8282\u70b9db
+redkale.cachesource[usersession].node[0].db = 0
+
+#\u7b80\u5316\u5199\u6cd5: \u53ef\u4ee5\u4e0d\u7528.node[0], \u5c06\u53c2\u6570\u90fd\u5408\u5e76\u5230url\u4e2d
+redkale.cachesource[usersession].url = redis://user:123456@127.0.0.1:6363?db=0
+
+
+# DataSource   @Resource(name="platf")
+# type\u53ef\u4ee5\u4e0d\u7528\u8bbe\u7f6e\uff0c\u6846\u67b6\u4f1a\u6839\u636eurl\u5224\u65ad\u4f7f\u7528\u54ea\u4e2aDataSource\u5b9e\u73b0\u7c7b\uff0c\u9ed8\u8ba4\u503c: org.redkale.source.DataJdbcSource
+redkale.datasource[platf].type = org.redkale.source.DataJdbcSource
+# \u662f\u5426\u5f00\u542f\u7f13\u5b58(\u6807\u8bb0\u4e3a@Cacheable\u7684Entity\u7c7b)\uff0c\u503c\u76ee\u524d\u53ea\u652f\u6301\u4e24\u79cd\uff1a ALL: \u6240\u6709\u5f00\u542f\u7f13\u5b58\u3002 NONE: \u5173\u95ed\u6240\u6709\u7f13\u5b58\uff0c \u975eNONE\u5b57\u6837\u7edf\u4e00\u89c6\u4e3aALL
+redkale.datasource[platf].cachemode = ALL
+# \u662f\u5426\u81ea\u52a8\u5efa\u8868\u5f53\u8868\u4e0d\u5b58\u5728\u7684\u65f6\u5019\uff0c \u76ee\u524d\u53ea\u652f\u6301mysql\u3001postgres\uff0c \u9ed8\u8ba4\u4e3afalse
+redkale.datasource[platf].table-autoddl = false
+# \u7528\u6237
+redkale.datasource[platf].user = root
+# \u5bc6\u7801
+redkale.datasource[platf].password = 12345678
+# \u591a\u4e2aURL\u7528;\u9694\u5f00\uff0c\u5982\u5206\u5e03\u5f0fSearchSource\u9700\u8981\u914d\u591a\u4e2aURL
+redkale.datasource[platf].url = jdbc:mysql://127.0.0.1:3306/platf?allowPublicKeyRetrieval=true&rewriteBatchedStatements=true&serverTimezone=UTC&characterEncoding=utf8
+# \u6700\u5927\u8fde\u63a5\u6570\uff0c\u9ed8\u8ba4\u503c\uff1aCPU\u6570
+redkale.datasource[platf].maxconns = 16
+# \u5305\u542b\u7684SQL\u6a21\u677f\uff0c\u76f8\u5f53\u4e8e\u53cd\u5411LIKE\uff0c\u4e0d\u540c\u7684JDBC\u9a71\u52a8\u7684SQL\u8bed\u53e5\u4e0d\u4e00\u6837\uff0cRedkale\u5185\u7f6e\u4e86MySQL\u7684\u8bed\u53e5
+redkale.datasource[platf].contain-sqltemplate = LOCATE(${keystr}, ${column}) > 0
+# \u5305\u542b\u7684SQL\u6a21\u677f\uff0c\u76f8\u5f53\u4e8e\u53cd\u5411LIKE\uff0c\u4e0d\u540c\u7684JDBC\u9a71\u52a8\u7684SQL\u8bed\u53e5\u4e0d\u4e00\u6837\uff0cRedkale\u5185\u7f6e\u4e86MySQL\u7684\u8bed\u53e5
+redkale.datasource[platf].notcontain-sqltemplate = LOCATE(${keystr}, ${column}) = 0
+# \u590d\u5236\u8868\u7ed3\u6784\u7684SQL\u6a21\u677f\uff0cRedkale\u5185\u7f6e\u4e86MySQL\u7684\u8bed\u53e5
+redkale.datasource[platf].tablenotexist-sqlstates = 42000;42S02
+# \u590d\u5236\u8868\u7ed3\u6784\u7684SQL\u6a21\u677f\uff0cRedkale\u5185\u7f6e\u4e86MySQL\u7684\u8bed\u53e5
+redkale.datasource[platf].tablecopy-sqltemplate = CREATE TABLE IF NOT EXISTS ${newtable} LIKE ${oldtable}
+
+
+# DataSource \u8bfb\u5199\u5206\u79bb
+redkale.datasource[platf].read.url = jdbc:mysql://127.0.0.1:3306/platf_r?allowPublicKeyRetrieval=true&rewriteBatchedStatements=true&serverTimezone=UTC&characterEncoding=utf8
+redkale.datasource[platf].read.user = root
+redkale.datasource[platf].read.password = 12345678
+
+redkale.datasource[platf].write.url = jdbc:mysql://127.0.0.1:3306/platf_w?allowPublicKeyRetrieval=true&rewriteBatchedStatements=true&serverTimezone=UTC&characterEncoding=utf8
+redkale.datasource[platf].write.user = root
+redkale.datasource[platf].write.password = 12345678

src/main/java/javax/annotation/Priority.java

@@ -29,5 +29,11 @@ import java.lang.annotation.Target;
 @Target({ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Priority {
+
+    /**
+     * 优先级值
+     *
+     * @return int
+     */
     int value();
 }

src/main/java/javax/annotation/Resource.java

@@ -0,0 +1,83 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package javax.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @since Common Annotations 1.0
+ */
+@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Resource {
+
+//    /**
+//     * AuthenticationType
+//     */
+//    @Deprecated
+//    public enum AuthenticationType {
+//        /**
+//         * @deprecated
+//         */
+//        CONTAINER,
+//        /**
+//         * @deprecated
+//         */
+//        APPLICATION
+//    }
+
+    /**
+     * 资源名称
+     *
+     * @return String
+     */
+    public String name() default "";
+
+    /**
+     * 依赖注入的类型
+     *
+     * @return Class
+     */
+    public Class<?> type() default Object.class;
+//
+//    /**
+//     *
+//     * @return AuthenticationType
+//     */
+//    @Deprecated
+//    public AuthenticationType authenticationType() default AuthenticationType.CONTAINER;
+//
+//    /**
+//     *
+//     * @return boolean
+//     */
+//    @Deprecated
+//    public boolean shareable() default true;
+//
+//    /**
+//     *
+//     * @return String
+//     */
+//    @Deprecated
+//    public String description() default "";
+//
+//    /**
+//     *
+//     * @return String
+//     */
+//    @Deprecated
+//    public String mappedName() default "";
+//
+//    /**
+//     *
+//     * @return String
+//     */
+//    @Deprecated
+//    public String lookup() default "";
+}

src/main/java/javax/persistence/Column.java

@@ -81,12 +81,19 @@ public @interface Column {
     boolean unique() default false;
 
     /**
-     * (Optional) Whether the database column is nullable.
+     * (Optional) Whether the database column is required.
      *
      * @return boolean
      */
     boolean nullable() default true;
 
+    /**
+     * for OpenAPI Specification 3
+     *
+     * @return String
+     */
+    String example() default "";
+
     /**
      * (Optional) Whether the column is included in SQL INSERT
      * statements generated by the persistence provider.
@@ -109,11 +116,18 @@ public @interface Column {
      *
      * @return String
      */
+    @Deprecated
     String table() default "";
 
     /**
      * (Optional) The column length. (Applies only if a
      * string-valued column is used.)
+     * if type==String and length == 65535 then sqltype is TEXT   <br>
+     * if type==String and length &#60;= 16777215 then sqltype is MEDIUMTEXT   <br>
+     * if type==String and length &#62; 16777215 then sqltype is LONGTEXT   <br>
+     * if type==byte[] and length &#60;= 65535 then sqltype is BLOB   <br>
+     * if type==byte[] and length &#60;= 16777215 then sqltype is MEDIUMBLOB   <br>
+     * if type==byte[] and length &#62; 16777215 then sqltype is LONGBLOB   <br>
      *
      * @return int
      */

src/main/java/javax/persistence/Entity.java

@@ -15,9 +15,7 @@
  ******************************************************************************/ 
 package javax.persistence;
 
-import java.lang.annotation.Target;
-import java.lang.annotation.Retention;
-import java.lang.annotation.Documented;
+import java.lang.annotation.*;
 import static java.lang.annotation.ElementType.TYPE;
 import static java.lang.annotation.RetentionPolicy.RUNTIME;
 
@@ -27,6 +25,7 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
  * 
  * @since Java Persistence 1.0
  */
+@Inherited
 @Documented
 @Target(TYPE)
 @Retention(RUNTIME)

src/main/java/javax/persistence/Table.java

@@ -82,6 +82,11 @@ public @interface Table {
      */
     Index[] indexes() default {};
 
+    /**
+     * comment
+     * 
+     * @return String
+     */
     String comment() default "";
 
 }

src/main/java/module-info.java

@@ -4,26 +4,29 @@
  *
  * @author zhangjx
  *
-module org.redkale {
+ */
+module redkale {
 
     requires java.base;
     requires java.logging;    
-    requires java.xml;
+    requires java.net.http;
     requires java.sql;
-
     requires jdk.unsupported;  //sun.misc.Unsafe
 
     exports javax.annotation;
     exports javax.persistence;
 
+    exports org.redkale.asm;
     exports org.redkale.boot;
     exports org.redkale.boot.watch;
+    exports org.redkale.cluster;
     exports org.redkale.convert;
     exports org.redkale.convert.bson;
     exports org.redkale.convert.ext;
     exports org.redkale.convert.json;
     exports org.redkale.mq;
     exports org.redkale.net;
+    exports org.redkale.net.client;
     exports org.redkale.net.http;
     exports org.redkale.net.sncp;
     exports org.redkale.service;
@@ -31,10 +34,11 @@ module org.redkale {
     exports org.redkale.util;
     exports org.redkale.watch;
     
-    uses org.redkale.cluster.ClusterAgent;
     uses org.redkale.mq.MessageAgent;
-    uses org.redkale.source.CacheSource;
-    uses org.redkale.source.SourceLoader;
-    uses org.redkale.util.ResourceInjectLoader;
+    uses org.redkale.cluster.ClusterAgent;
+    uses org.redkale.convert.ConvertProvider;
+    uses org.redkale.source.CacheSourceProvider;
+    uses org.redkale.source.DataSourceProvider;
+    uses org.redkale.util.ResourceAnnotationProvider;
+    
 }
-*/

src/main/java/org/redkale/asm/AnnotationVisitor.java

@@ -102,9 +102,6 @@ public abstract class AnnotationVisitor {
      *            method calls. May be null.
      */
     public AnnotationVisitor(final int api, final AnnotationVisitor av) {
-        if (api < Opcodes.ASM4 || api > Opcodes.ASM6) {
-            throw new IllegalArgumentException();
-        }
         this.api = api;
         this.av = av;
     }

src/main/java/org/redkale/asm/Attribute.java

@@ -286,8 +286,13 @@ public class Attribute {
 
     //The stuff below is temporary - once proper support for nestmate attribute has been added, it can be safely removed.
     //see also changes in ClassReader.accept.
-
+    /**
+     * 
+     */
     public static class NestMembers extends Attribute {
+        /**
+         * 
+         */
         public NestMembers() {
             super("NestMembers");
         }
@@ -321,11 +326,16 @@ public class Attribute {
         }
     }
 
+    /**
+     * 
+     */
     public static class NestHost extends Attribute {
 
         byte[] bytes;
         String clazz;
-
+        /**
+         * 
+         */
         public NestHost() {
             super("NestHost");
         }

src/main/java/org/redkale/asm/ClassVisitor.java

@@ -104,9 +104,6 @@ public abstract class ClassVisitor {
      *            calls. May be null.
      */
     public ClassVisitor(final int api, final ClassVisitor cv) {
-        if (api < Opcodes.ASM4 || api > Opcodes.ASM6) {
-            throw new IllegalArgumentException();
-        }
         this.api = api;
         this.cv = cv;
     }
@@ -244,9 +241,6 @@ public abstract class ClassVisitor {
      */
     public AnnotationVisitor visitTypeAnnotation(int typeRef,
             TypePath typePath, String desc, boolean visible) {
-        if (api < Opcodes.ASM5) {
-            throw new RuntimeException();
-        }
         if (cv != null) {
             return cv.visitTypeAnnotation(typeRef, typePath, desc, visible);
         }

src/main/java/org/redkale/asm/ClassWriter.java

@@ -1297,38 +1297,6 @@ public class ClassWriter extends ClassVisitor {
         return result;
     }
 
-    /**
-     * Adds a handle to the constant pool of the class being build. Does nothing
-     * if the constant pool already contains a similar item. <i>This method is
-     * intended for {@link Attribute} sub classes, and is normally not needed by
-     * class generators or adapters.</i>
-     *
-     * @param tag
-     *            the kind of this handle. Must be {@link Opcodes#H_GETFIELD},
-     *            {@link Opcodes#H_GETSTATIC}, {@link Opcodes#H_PUTFIELD},
-     *            {@link Opcodes#H_PUTSTATIC}, {@link Opcodes#H_INVOKEVIRTUAL},
-     *            {@link Opcodes#H_INVOKESTATIC},
-     *            {@link Opcodes#H_INVOKESPECIAL},
-     *            {@link Opcodes#H_NEWINVOKESPECIAL} or
-     *            {@link Opcodes#H_INVOKEINTERFACE}.
-     * @param owner
-     *            the internal name of the field or method owner class.
-     * @param name
-     *            the name of the field or method.
-     * @param desc
-     *            the descriptor of the field or method.
-     * @return the index of a new or already existing method type reference
-     *         item.
-     *
-     * @deprecated this method is superseded by
-     *             {@link #newHandle(int, String, String, String, boolean)}.
-     */
-    @Deprecated
-    public int newHandle(final int tag, final String owner, final String name,
-            final String desc) {
-        return newHandle(tag, owner, name, desc, tag == Opcodes.H_INVOKEINTERFACE);
-    }
-
     /**
      * Adds a handle to the constant pool of the class being build. Does nothing
      * if the constant pool already contains a similar item. <i>This method is

src/main/java/org/redkale/asm/FieldVisitor.java

@@ -101,9 +101,6 @@ public abstract class FieldVisitor {
      *            calls. May be null.
      */
     public FieldVisitor(final int api, final FieldVisitor fv) {
-        if (api < Opcodes.ASM4 || api > Opcodes.ASM6) {
-            throw new IllegalArgumentException();
-        }
         this.api = api;
         this.fv = fv;
     }
@@ -145,9 +142,6 @@ public abstract class FieldVisitor {
      */
     public AnnotationVisitor visitTypeAnnotation(int typeRef,
             TypePath typePath, String desc, boolean visible) {
-        if (api < Opcodes.ASM5) {
-            throw new RuntimeException();
-        }
         if (fv != null) {
             return fv.visitTypeAnnotation(typeRef, typePath, desc, visible);
         }

src/main/java/org/redkale/asm/Handle.java

@@ -99,35 +99,6 @@ public final class Handle {
      */
     final boolean itf;
 
-    /**
-     * Constructs a new field or method handle.
-     *
-     * @param tag
-     *            the kind of field or method designated by this Handle. Must be
-     *            {@link Opcodes#H_GETFIELD}, {@link Opcodes#H_GETSTATIC},
-     *            {@link Opcodes#H_PUTFIELD}, {@link Opcodes#H_PUTSTATIC},
-     *            {@link Opcodes#H_INVOKEVIRTUAL},
-     *            {@link Opcodes#H_INVOKESTATIC},
-     *            {@link Opcodes#H_INVOKESPECIAL},
-     *            {@link Opcodes#H_NEWINVOKESPECIAL} or
-     *            {@link Opcodes#H_INVOKEINTERFACE}.
-     * @param owner
-     *            the internal name of the class that owns the field or method
-     *            designated by this handle.
-     * @param name
-     *            the name of the field or method designated by this handle.
-     * @param desc
-     *            the descriptor of the field or method designated by this
-     *            handle.
-     *
-     * @deprecated this constructor has been superseded
-     *             by {@link #Handle(int, String, String, String, boolean)}.
-     */
-    @Deprecated
-    public Handle(int tag, String owner, String name, String desc) {
-        this(tag, owner, name, desc, tag == Opcodes.H_INVOKEINTERFACE);
-    }
-
     /**
      * Constructs a new field or method handle.
      *

src/main/java/org/redkale/asm/MethodDebugVisitor.java

@@ -5,7 +5,10 @@
  */
 package org.redkale.asm;
 
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
 import java.util.*;
+import static org.redkale.asm.Opcodes.*;
 
 /**
  * MethodVisitor 的调试类
@@ -54,11 +57,20 @@ public class MethodDebugVisitor {
         }
     }
 
+    /**
+     *
+     * @param visitor MethodVisitor
+     */
     public MethodDebugVisitor(MethodVisitor visitor) {
         //super(Opcodes.ASM5, visitor);
         this.visitor = visitor;
     }
 
+    public void visitTryCatchBlock(Label start, Label end, Label handler, String type) {
+        visitor.visitTryCatchBlock(start, end, handler, type);
+        if (debug) System.out.println("mv.visitTryCatchBlock(label0, label1, label2, \"" + type + "\");");
+    }
+
     public AnnotationVisitor visitParameterAnnotation(int i, String string, boolean bln) {
         AnnotationVisitor av = visitor.visitParameterAnnotation(i, string, bln);
         if (debug) System.out.println("mv.visitParameterAnnotation(" + i + ", \"" + string + "\", " + bln + ");");
@@ -189,4 +201,74 @@ public class MethodDebugVisitor {
         visitor.visitEnd();
         if (debug) System.out.println("mv.visitEnd();\r\n\r\n\r\n");
     }
+
+    public static void pushInt(MethodDebugVisitor mv, int num) {
+        if (num < 6) {
+            mv.visitInsn(ICONST_0 + num);
+        } else if (num <= Byte.MAX_VALUE) {
+            mv.visitIntInsn(BIPUSH, num);
+        } else if (num <= Short.MAX_VALUE) {
+            mv.visitIntInsn(SIPUSH, num);
+        } else {
+            mv.visitLdcInsn(num);
+        }
+    }
+
+    public static void pushInt(MethodVisitor mv, int num) {
+        if (num < 6) {
+            mv.visitInsn(ICONST_0 + num);
+        } else if (num <= Byte.MAX_VALUE) {
+            mv.visitIntInsn(BIPUSH, num);
+        } else if (num <= Short.MAX_VALUE) {
+            mv.visitIntInsn(SIPUSH, num);
+        } else {
+            mv.visitLdcInsn(num);
+        }
+    }
+
+    public static void visitAnnotation(final AnnotationVisitor av, final Annotation ann) {
+        try {
+            for (Method anm : ann.annotationType().getMethods()) {
+                final String mname = anm.getName();
+                if ("equals".equals(mname) || "hashCode".equals(mname) || "toString".equals(mname) || "annotationType".equals(mname)) continue;
+                final Object r = anm.invoke(ann);
+                if (r instanceof String[]) {
+                    AnnotationVisitor av1 = av.visitArray(mname);
+                    for (String item : (String[]) r) {
+                        av1.visit(null, item);
+                    }
+                    av1.visitEnd();
+                } else if (r instanceof Class[]) {
+                    AnnotationVisitor av1 = av.visitArray(mname);
+                    for (Class item : (Class[]) r) {
+                        av1.visit(null, Type.getType(item));
+                    }
+                    av1.visitEnd();
+                } else if (r instanceof Enum[]) {
+                    AnnotationVisitor av1 = av.visitArray(mname);
+                    for (Enum item : (Enum[]) r) {
+                        av1.visitEnum(null, Type.getDescriptor(item.getClass()), ((Enum) item).name());
+                    }
+                    av1.visitEnd();
+                } else if (r instanceof Annotation[]) {
+                    AnnotationVisitor av1 = av.visitArray(mname);
+                    for (Annotation item : (Annotation[]) r) {
+                        visitAnnotation(av1.visitAnnotation(null, Type.getDescriptor(((Annotation) item).annotationType())), item);
+                    }
+                    av1.visitEnd();
+                } else if (r instanceof Class) {
+                    av.visit(mname, Type.getType((Class) r));
+                } else if (r instanceof Enum) {
+                    av.visitEnum(mname, Type.getDescriptor(r.getClass()), ((Enum) r).name());
+                } else if (r instanceof Annotation) {
+                    visitAnnotation(av.visitAnnotation(null, Type.getDescriptor(((Annotation) r).annotationType())), (Annotation) r);
+                } else {
+                    av.visit(mname, r);
+                }
+            }
+            av.visitEnd();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
 }

src/main/java/org/redkale/asm/MethodVisitor.java

@@ -118,9 +118,6 @@ public abstract class MethodVisitor {
      *            calls. May be null.
      */
     public MethodVisitor(final int api, final MethodVisitor mv) {
-        if (api < Opcodes.ASM4 || api > Opcodes.ASM6) {
-            throw new IllegalArgumentException();
-        }
         this.api = api;
         this.mv = mv;
     }
@@ -140,9 +137,6 @@ public abstract class MethodVisitor {
      *            allowed (see {@link Opcodes}).
      */
     public void visitParameter(String name, int access) {
-        if (api < Opcodes.ASM5) {
-            throw new RuntimeException();
-        }
         if (mv != null) {
             mv.visitParameter(name, access);
         }
@@ -209,9 +203,6 @@ public abstract class MethodVisitor {
      */
     public AnnotationVisitor visitTypeAnnotation(int typeRef,
             TypePath typePath, String desc, boolean visible) {
-        if (api < Opcodes.ASM5) {
-            throw new RuntimeException();
-        }
         if (mv != null) {
             return mv.visitTypeAnnotation(typeRef, typePath, desc, visible);
         }
@@ -453,35 +444,6 @@ public abstract class MethodVisitor {
         }
     }
 
-    /**
-     * Visits a method instruction. A method instruction is an instruction that
-     * invokes a method.
-     *
-     * @param opcode
-     *            the opcode of the type instruction to be visited. This opcode
-     *            is either INVOKEVIRTUAL, INVOKESPECIAL, INVOKESTATIC or
-     *            INVOKEINTERFACE.
-     * @param owner
-     *            the internal name of the method's owner class (see
-     *            {@link Type#getInternalName() getInternalName}).
-     * @param name
-     *            the method's name.
-     * @param desc
-     *            the method's descriptor (see {@link Type Type}).
-     */
-    @Deprecated
-    public void visitMethodInsn(int opcode, String owner, String name,
-            String desc) {
-        if (api >= Opcodes.ASM5) {
-            boolean itf = opcode == Opcodes.INVOKEINTERFACE;
-            visitMethodInsn(opcode, owner, name, desc, itf);
-            return;
-        }
-        if (mv != null) {
-            mv.visitMethodInsn(opcode, owner, name, desc);
-        }
-    }
-
     /**
      * Visits a method instruction. A method instruction is an instruction that
      * invokes a method.
@@ -502,14 +464,6 @@ public abstract class MethodVisitor {
      */
     public void visitMethodInsn(int opcode, String owner, String name,
             String desc, boolean itf) {
-        if (api < Opcodes.ASM5) {
-            if (itf != (opcode == Opcodes.INVOKEINTERFACE)) {
-                throw new IllegalArgumentException(
-                        "INVOKESPECIAL/STATIC on interfaces require ASM 5");
-            }
-            visitMethodInsn(opcode, owner, name, desc);
-            return;
-        }
         if (mv != null) {
             mv.visitMethodInsn(opcode, owner, name, desc, itf);
         }
@@ -723,9 +677,6 @@ public abstract class MethodVisitor {
      */
     public AnnotationVisitor visitInsnAnnotation(int typeRef,
             TypePath typePath, String desc, boolean visible) {
-        if (api < Opcodes.ASM5) {
-            throw new RuntimeException();
-        }
         if (mv != null) {
             return mv.visitInsnAnnotation(typeRef, typePath, desc, visible);
         }
@@ -783,9 +734,6 @@ public abstract class MethodVisitor {
      */
     public AnnotationVisitor visitTryCatchAnnotation(int typeRef,
             TypePath typePath, String desc, boolean visible) {
-        if (api < Opcodes.ASM5) {
-            throw new RuntimeException();
-        }
         if (mv != null) {
             return mv.visitTryCatchAnnotation(typeRef, typePath, desc, visible);
         }
@@ -854,9 +802,6 @@ public abstract class MethodVisitor {
     public AnnotationVisitor visitLocalVariableAnnotation(int typeRef,
             TypePath typePath, Label[] start, Label[] end, int[] index,
             String desc, boolean visible) {
-        if (api < Opcodes.ASM5) {
-            throw new RuntimeException();
-        }
         if (mv != null) {
             return mv.visitLocalVariableAnnotation(typeRef, typePath, start,
                     end, index, desc, visible);

src/main/java/org/redkale/asm/Opcodes.java

@@ -73,10 +73,9 @@ package org.redkale.asm;
 public interface Opcodes {
 
     // ASM API versions
-
-    int ASM4 = 4 << 16 | 0 << 8 | 0;
-    int ASM5 = 5 << 16 | 0 << 8 | 0;
-    int ASM6 = 6 << 16 | 0 << 8 | 0;
+    int ASM4 = 4 << 16 | 0 << 8;
+    int ASM5 = 5 << 16 | 0 << 8;
+    int ASM6 = 6 << 16 | 0 << 8;
 
     // versions
 

src/main/java/org/redkale/asm/TypePath.java

@@ -161,7 +161,7 @@ public class TypePath {
      * @return the corresponding TypePath object, or null if the path is empty.
      */
     public static TypePath fromString(final String typePath) {
-        if (typePath == null || typePath.length() == 0) {
+        if (typePath == null || typePath.isEmpty()) {
             return null;
         }
         int n = typePath.length();

src/main/java/org/redkale/boot/ApiDocCommand.java

@@ -0,0 +1,656 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.redkale.boot;
+
+import java.io.*;
+import java.lang.reflect.*;
+import java.math.*;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.*;
+import java.util.logging.*;
+import javax.persistence.*;
+import org.redkale.convert.*;
+import org.redkale.convert.json.*;
+import org.redkale.mq.MessageMultiConsumer;
+import org.redkale.net.http.*;
+import org.redkale.service.RetResult;
+import org.redkale.source.*;
+import org.redkale.util.*;
+
+/**
+ * API接口文档生成类，作用：生成Application实例中所有HttpServer的可用HttpServlet的API接口方法   <br>
+ * 继承 HttpBaseServlet 是为了获取 HttpMapping 信息 <br>
+ * https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md
+ *
+ * <p>
+ * 详情见: https://redkale.org
+ *
+ * @author zhangjx
+ */
+public final class ApiDocCommand {
+
+    private static final java.lang.reflect.Type TYPE_RETRESULT_OBJECT = new TypeToken<RetResult<Object>>() {
+    }.getType();
+
+    private static final java.lang.reflect.Type TYPE_RETRESULT_STRING = new TypeToken<RetResult<String>>() {
+    }.getType();
+
+    private static final java.lang.reflect.Type TYPE_RETRESULT_INTEGER = new TypeToken<RetResult<Integer>>() {
+    }.getType();
+
+    private static final java.lang.reflect.Type TYPE_RETRESULT_LONG = new TypeToken<RetResult<Long>>() {
+    }.getType();
+
+    private final Application app; //Application全局对象
+
+    public ApiDocCommand(Application app) {
+        this.app = app;
+    }
+
+    public String command(String cmd, String[] params) throws Exception {
+        //是否跳过RPC接口
+        boolean skipRPC = true;
+        String apiHost = "http://localhost";
+
+        if (params != null && params.length > 0) {
+            for (String param : params) {
+                if (param == null) continue;
+                param = param.toLowerCase();
+                if (param.startsWith("--api-skiprpc=")) {
+                    skipRPC = "true".equalsIgnoreCase(param.substring("--api-skiprpc=".length()));
+                } else if (param.startsWith("--api-host=")) {
+                    apiHost = param.substring("--api-host=".length());
+                }
+            }
+        }
+
+        List<Map> serverList = new ArrayList<>();
+        Field __prefix = HttpServlet.class.getDeclaredField("_prefix");
+        __prefix.setAccessible(true);
+        Map<String, Map<String, Map<String, Object>>> typesMap = new LinkedHashMap<>();
+        //https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md
+        Map<String, Object> swaggerPathsMap = new LinkedHashMap<>();
+        List<Map> swaggerServers = new ArrayList<>();
+        List<Map> swaggerTags = new ArrayList<>();
+        Map<String, Map<String, Object>> swaggerComponentsMap = new LinkedHashMap<>();
+        for (NodeServer node : app.servers) {
+            if (!(node instanceof NodeHttpServer)) continue;
+            final Map<String, Object> map = new LinkedHashMap<>();
+            serverList.add(map);
+            HttpServer server = node.getServer();
+            map.put("address", server.getSocketAddress());
+            swaggerServers.add(Utility.ofMap("url", apiHost + ":" + server.getSocketAddress().getPort()));
+            List<Map<String, Object>> servletsList = new ArrayList<>();
+            map.put("servlets", servletsList);
+            String plainContentType = server.getResponseConfig() == null ? "application/json" : server.getResponseConfig().plainContentType;
+            if (plainContentType == null || plainContentType.isEmpty()) plainContentType = "application/json";
+            if (plainContentType.indexOf(';') > 0) plainContentType = plainContentType.substring(0, plainContentType.indexOf(';'));
+
+            for (HttpServlet servlet : server.getDispatcherServlet().getServlets()) {
+                if (!(servlet instanceof HttpServlet)) continue;
+                if (servlet instanceof WebSocketServlet) continue;
+                if (servlet.getClass().getAnnotation(MessageMultiConsumer.class) != null) {
+                    node.logger.log(Level.INFO, servlet + " be skipped because has @MessageMultiConsumer");
+                    continue;
+                }
+                WebServlet ws = servlet.getClass().getAnnotation(WebServlet.class);
+                if (ws == null) {
+                    node.logger.log(Level.WARNING, servlet + " not found @WebServlet");
+                    continue;
+                }
+                if (ws.name().isEmpty()) {
+                    node.logger.log(Level.INFO, servlet + " be skipped because @WebServlet.name is empty");
+                    continue;
+                }
+                final String tag = ws.name().isEmpty() ? servlet.getClass().getSimpleName().replace("Servlet", "").toLowerCase() : ws.name();
+                final Map<String, Object> servletMap = new LinkedHashMap<>();
+                String prefix = (String) __prefix.get(servlet);
+                String[] urlregs = ws.value();
+                if (prefix != null && !prefix.isEmpty()) {
+                    for (int i = 0; i < urlregs.length; i++) {
+                        urlregs[i] = prefix + urlregs[i];
+                    }
+                }
+                servletMap.put("urlregs", urlregs);
+                servletMap.put("moduleid", ws.moduleid());
+                servletMap.put("name", ws.name());
+                servletMap.put("comment", ws.comment());
+
+                List<Map> mappingsList = new ArrayList<>();
+                servletMap.put("mappings", mappingsList);
+                final Class selfClz = servlet.getClass();
+                Class clz = servlet.getClass();
+                HashSet<String> actionUrls = new HashSet<>();
+                do {
+                    if (Modifier.isAbstract(clz.getModifiers())) break;
+                    for (Method method : clz.getMethods()) {
+                        if (method.getParameterCount() != 2) continue;
+                        HttpMapping action = method.getAnnotation(HttpMapping.class);
+                        if (action == null) continue;
+                        if (!action.inherited() && selfClz != clz) continue; //忽略不被继承的方法
+                        if (actionUrls.contains(action.url())) continue;
+                        if (HttpScope.class.isAssignableFrom(action.result())) continue; //忽略模板引擎的方法
+                        if (action.rpconly() && skipRPC) continue; //不生成RPC接口
+
+                        final List<Map<String, Object>> swaggerParamsList = new ArrayList<>();
+
+                        final Map<String, Object> mappingMap = new LinkedHashMap<>();
+                        mappingMap.put("url", prefix + action.url());
+                        actionUrls.add(action.url());
+                        mappingMap.put("auth", action.auth());
+                        mappingMap.put("actionid", action.actionid());
+                        mappingMap.put("comment", action.comment());
+                        List<Map> paramsList = new ArrayList<>();
+                        mappingMap.put("params", paramsList);
+                        List<String> results = new ArrayList<>();
+                        Type resultType = action.result();
+                        if (!action.resultref().isEmpty()) {
+                            Field f = servlet.getClass().getDeclaredField(action.resultref());
+                            f.setAccessible(true);
+                            resultType = (Type) f.get(servlet);
+                        }
+//                        for (final Class rtype : action.results()) {
+//                            results.add(rtype.getName());
+//                            if (typesMap.containsKey(rtype.getName())) continue;
+//                            if (rtype.getName().startsWith("java.")) continue;
+//                            if (rtype.getName().startsWith("javax.")) continue;
+//                            final boolean filter = FilterBean.class.isAssignableFrom(rtype);
+//                            final Map<String, Map<String, Object>> typeMap = new LinkedHashMap<>();
+//                            Class loop = rtype;
+//                            do {
+//                                if (loop == null || loop.isInterface()) break;
+//                                for (Field field : loop.getDeclaredFields()) {
+//                                    if (Modifier.isFinal(field.getModifiers())) continue;
+//                                    if (Modifier.isStatic(field.getModifiers())) continue;
+//
+//                                    Map<String, Object> fieldmap = new LinkedHashMap<>();
+//                                    fieldmap.put("type", field.getType().isArray() ? (field.getType().getComponentType().getName() + "[]") : field.getGenericType().getTypeName());
+//
+//                                    Comment comment = field.getAnnotation(Comment.class);
+//                                    Column col = field.getAnnotation(Column.class);
+//                                    FilterColumn fc = field.getAnnotation(FilterColumn.class);
+//                                    if (comment != null) {
+//                                        fieldmap.put("comment", comment.value());
+//                                    } else if (col != null) {
+//                                        fieldmap.put("comment", col.comment());
+//                                    } else if (fc != null) {
+//                                        fieldmap.put("comment", fc.comment());
+//                                    }
+//                                    fieldmap.put("primary", !filter && (field.getAnnotation(Id.class) != null));
+//                                    fieldmap.put("updatable", (filter || col == null || col.updatable()));
+//                                    if (servlet.getClass().getAnnotation(Rest.RestDyn.class) != null) {
+//                                        if (field.getAnnotation(RestAddress.class) != null) continue;
+//                                    }
+//
+//                                    typeMap.put(field.getName(), fieldmap);
+//                                }
+//                            } while ((loop = loop.getSuperclass()) != Object.class);
+//                            typesMap.put(rtype.getName(), typeMap);
+//                        }
+                        mappingMap.put("results", results);
+                        boolean hasbodyparam = false;
+                        Map<String, Object> swaggerRequestBody = new LinkedHashMap<>();
+                        for (HttpParam param : method.getAnnotationsByType(HttpParam.class)) {
+                            final Map<String, Object> oldapisParamMap = new LinkedHashMap<>();
+                            final boolean isarray = param.type().isArray();
+                            final Class ptype = isarray ? param.type().getComponentType() : param.type();
+                            oldapisParamMap.put("name", param.name());
+                            oldapisParamMap.put("radix", param.radix());
+                            oldapisParamMap.put("type", ptype.getName() + (isarray ? "[]" : ""));
+                            oldapisParamMap.put("style", param.style());
+                            oldapisParamMap.put("comment", param.comment());
+                            oldapisParamMap.put("required", param.required());
+                            paramsList.add(oldapisParamMap);
+                            {
+                                final Map<String, Object> paramSchemaMap = new LinkedHashMap<>();
+                                Type paramGenericType = param.type();
+                                if (!param.typeref().isEmpty()) {
+                                    Field f = servlet.getClass().getDeclaredField(param.typeref());
+                                    f.setAccessible(true);
+                                    paramGenericType = (Type) f.get(servlet);
+                                }
+                                simpleSchemaType(null, node.getLogger(), swaggerComponentsMap, param.type(), paramGenericType, paramSchemaMap, true);
+                                if (param.style() == HttpParam.HttpParameterStyle.BODY) {
+                                    swaggerRequestBody.put("description", param.comment());
+                                    swaggerRequestBody.put("content", Utility.ofMap(plainContentType, Utility.ofMap("schema", paramSchemaMap)));
+                                } else {
+                                    final Map<String, Object> swaggerParamMap = new LinkedHashMap<>();
+                                    swaggerParamMap.put("name", param.name());
+                                    swaggerParamMap.put("in", param.style().name().toLowerCase());
+                                    swaggerParamMap.put("description", param.comment());
+                                    swaggerParamMap.put("required", param.required());
+                                    if (param.deprecated()) {
+                                        swaggerParamMap.put("deprecated", param.deprecated());
+                                    }
+                                    //https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameterStyle
+                                    swaggerParamMap.put("style", param.style() == HttpParam.HttpParameterStyle.HEADER || param.name().indexOf('#') == 0 ? "simple" : "form");
+                                    swaggerParamMap.put("explode", true);
+                                    swaggerParamMap.put("schema", paramSchemaMap);
+                                    Object example = formatExample(null, param.example(), param.type(), paramGenericType);
+                                    if (example != null) {
+                                        swaggerParamMap.put("example", example);
+                                    } else if (!param.example().isEmpty()) {
+                                        swaggerParamMap.put("example", param.example());
+                                    }
+                                    swaggerParamsList.add(swaggerParamMap);
+                                }
+                            }
+                            if (param.style() == HttpParam.HttpParameterStyle.BODY) hasbodyparam = true;
+                            if (ptype.isPrimitive() || ptype == String.class) continue;
+                            if (typesMap.containsKey(ptype.getName())) continue;
+                            if (ptype.getName().startsWith("java.")) continue;
+                            if (ptype.getName().startsWith("javax.")) continue;
+
+                            final Map<String, Map<String, Object>> typeMap = new LinkedHashMap<>();
+                            Class loop = ptype;
+                            final boolean filter = FilterBean.class.isAssignableFrom(loop);
+                            do {
+                                if (loop == null || loop.isInterface()) break;
+                                for (Field field : loop.getDeclaredFields()) {
+                                    if (Modifier.isFinal(field.getModifiers())) continue;
+                                    if (Modifier.isStatic(field.getModifiers())) continue;
+
+                                    Map<String, Object> fieldmap = new LinkedHashMap<>();
+                                    fieldmap.put("type", field.getType().isArray() ? (field.getType().getComponentType().getName() + "[]") : field.getGenericType().getTypeName());
+
+                                    Column col = field.getAnnotation(Column.class);
+                                    FilterColumn fc = field.getAnnotation(FilterColumn.class);
+                                    Comment comment = field.getAnnotation(Comment.class);
+                                    if (comment != null) {
+                                        fieldmap.put("comment", comment.value());
+                                    } else if (col != null) {
+                                        fieldmap.put("comment", col.comment());
+                                    } else if (fc != null) {
+                                        fieldmap.put("comment", fc.comment());
+                                    }
+                                    fieldmap.put("primary", !filter && (field.getAnnotation(Id.class) != null));
+                                    fieldmap.put("updatable", (filter || col == null || col.updatable()));
+
+                                    if (servlet.getClass().getAnnotation(Rest.RestDyn.class) != null) {
+                                        if (field.getAnnotation(RestAddress.class) != null) continue;
+                                    }
+
+                                    typeMap.put(field.getName(), fieldmap);
+                                }
+                            } while ((loop = loop.getSuperclass()) != Object.class);
+
+                            typesMap.put(ptype.getName(), typeMap);
+                        }
+                        mappingMap.put("result", action.result().getSimpleName().replace("void", "Object"));
+                        mappingsList.add(mappingMap);
+
+                        final Map<String, Object> swaggerOperatMap = new LinkedHashMap<>();
+                        swaggerOperatMap.put("tags", new String[]{tag});
+                        swaggerOperatMap.put("operationId", action.name());
+                        if (method.getAnnotation(Deprecated.class) != null) {
+                            swaggerOperatMap.put("deprecated", true);
+                        }
+                        Map<String, Object> respSchemaMap = new LinkedHashMap<>();
+                        JsonFactory returnFactory = Rest.createJsonFactory(false, method.getAnnotationsByType(RestConvert.class), method.getAnnotationsByType(RestConvertCoder.class));
+                        simpleSchemaType(returnFactory, node.getLogger(), swaggerComponentsMap, action.result(), resultType, respSchemaMap, true);
+
+                        Map<String, Object> respMap = new LinkedHashMap<>();
+                        respMap.put("schema", respSchemaMap);
+                        Object example = formatExample(returnFactory, action.example(), action.result(), resultType);
+                        if (example != null) respSchemaMap.put("example", example);
+                        if (!swaggerRequestBody.isEmpty()) swaggerOperatMap.put("requestBody", swaggerRequestBody);
+                        swaggerOperatMap.put("parameters", swaggerParamsList);
+                        String actiondesc = action.comment();
+                        if (action.rpconly()) actiondesc = "[Only for RPC API] " + actiondesc;
+                        swaggerOperatMap.put("responses", Utility.ofMap("200", Utility.ofMap("description", actiondesc, "content", Utility.ofMap("application/json", respMap))));
+
+                        String m = action.methods() == null || action.methods().length == 0 ? null : action.methods()[0].toLowerCase();
+                        if (m == null) {
+                            m = hasbodyparam || TYPE_RETRESULT_STRING.equals(resultType) || TYPE_RETRESULT_INTEGER.equals(resultType)
+                                || TYPE_RETRESULT_LONG.equals(resultType) || action.name().contains("create") || action.name().contains("insert")
+                                || action.name().contains("update") || action.name().contains("delete") || action.name().contains("send") ? "post" : "get";
+                        }
+                        swaggerPathsMap.put(prefix + action.url(), Utility.ofMap("description", action.comment(), m, swaggerOperatMap));
+                    }
+                } while ((clz = clz.getSuperclass()) != HttpServlet.class);
+                mappingsList.sort((o1, o2) -> ((String) o1.get("url")).compareTo((String) o2.get("url")));
+                servletsList.add(servletMap);
+                if (!actionUrls.isEmpty()) swaggerTags.add(Utility.ofMap("name", tag, "description", ws.comment()));
+            }
+            servletsList.sort((o1, o2) -> {
+                String[] urlregs1 = (String[]) o1.get("urlregs");
+                String[] urlregs2 = (String[]) o2.get("urlregs");
+                return urlregs1.length > 0 ? (urlregs2.length > 0 ? urlregs1[0].compareTo(urlregs2[0]) : 1) : -1;
+            });
+        }
+        { // https://github.com/OAI/OpenAPI-Specification 
+            Map<String, Object> swaggerResultMap = new LinkedHashMap<>();
+            swaggerResultMap.put("openapi", "3.0.0");
+            Map<String, Object> infomap = new LinkedHashMap<>();
+            infomap.put("title", "Redkale generate apidoc");
+            infomap.put("version", "1.0.0");
+            swaggerResultMap.put("info", infomap);
+            swaggerResultMap.put("servers", swaggerServers);
+            swaggerResultMap.put("paths", swaggerPathsMap);
+            swaggerResultMap.put("tags", swaggerTags);
+            if (!swaggerComponentsMap.isEmpty()) swaggerResultMap.put("components", Utility.ofMap("schemas", swaggerComponentsMap));
+            final FileOutputStream out = new FileOutputStream(new File(app.getHome(), "openapi-doc.json"));
+            out.write(JsonConvert.root().convertTo(swaggerResultMap).getBytes(StandardCharsets.UTF_8));
+            out.close();
+        }
+        {
+            Map<String, Object> oldapisResultMap = new LinkedHashMap<>();
+            oldapisResultMap.put("servers", serverList);
+            oldapisResultMap.put("types", typesMap);
+            final String json = JsonConvert.root().convertTo(oldapisResultMap);
+            final FileOutputStream out = new FileOutputStream(new File(app.getHome(), "apidoc.json"));
+            out.write(json.getBytes(StandardCharsets.UTF_8));
+            out.close();
+            File doctemplate = new File(app.getConfPath().toString(), "apidoc-template.html");
+            InputStream in = null;
+            if (doctemplate.isFile() && doctemplate.canRead()) {
+                in = new FileInputStream(doctemplate);
+            }
+            if (in != null) {
+                String content = Utility.read(in).replace("'${content}'", json);
+                in.close();
+                FileOutputStream outhtml = new FileOutputStream(new File(app.getHome(), "apidoc.html"));
+                outhtml.write(content.getBytes(StandardCharsets.UTF_8));
+                outhtml.close();
+            }
+        }
+        return "apidoc success";
+    }
+
+    private static void simpleSchemaType(JsonFactory factory, Logger logger, Map<String, Map<String, Object>> componentsMap, Class type, Type genericType, Map<String, Object> schemaMap, boolean recursive) {
+        if (type == int.class || type == Integer.class || type == AtomicInteger.class) {
+            schemaMap.put("type", "integer");
+            schemaMap.put("format", "int32");
+        } else if (type == long.class || type == Long.class
+            || type == AtomicLong.class || type == LongAdder.class || type == BigInteger.class) {
+            schemaMap.put("type", "integer");
+            schemaMap.put("format", "int64");
+        } else if (type == float.class || type == Float.class) {
+            schemaMap.put("type", "number");
+            schemaMap.put("format", "float");
+        } else if (type == double.class || type == Double.class || type == BigDecimal.class) {
+            schemaMap.put("type", "number");
+            schemaMap.put("format", "double");
+        } else if (type == boolean.class || type == Boolean.class || type == AtomicBoolean.class) {
+            schemaMap.put("type", "boolean");
+        } else if (type.isPrimitive() || Number.class.isAssignableFrom(type)) {
+            schemaMap.put("type", "number");
+        } else if (type == String.class || CharSequence.class.isAssignableFrom(type)) {
+            schemaMap.put("type", "string");
+        } else if (recursive && (type.isArray() || Collection.class.isAssignableFrom(type))) {
+            schemaMap.put("type", "array");
+            Map<String, Object> sbumap = new LinkedHashMap<>();
+            if (type.isArray()) {
+                simpleSchemaType(factory, logger, componentsMap, type.getComponentType(), type.getComponentType(), sbumap, false);
+            } else if (genericType instanceof ParameterizedType) {
+                Type subpt = ((ParameterizedType) genericType).getActualTypeArguments()[0];
+                if (subpt instanceof Class) {
+                    simpleSchemaType(factory, logger, componentsMap, (Class) subpt, subpt, sbumap, false);
+                } else if (subpt instanceof ParameterizedType && ((ParameterizedType) subpt).getOwnerType() instanceof Class) {
+                    simpleSchemaType(factory, logger, componentsMap, (Class) ((ParameterizedType) subpt).getOwnerType(), subpt, sbumap, false);
+                } else {
+                    sbumap.put("type", "object");
+                }
+            } else {
+                sbumap.put("type", "object");
+            }
+            schemaMap.put("items", sbumap);
+        } else if (!type.getName().startsWith("java.") && !type.getName().startsWith("javax.")) {
+            String ct = simpleComponentType(factory, logger, componentsMap, type, genericType);
+            if (ct == null) {
+                schemaMap.put("type", "object");
+            } else {
+                schemaMap.put("$ref", "#/components/schemas/" + ct);
+            }
+        } else {
+            schemaMap.put("type", "object");
+        }
+    }
+
+    private static String simpleComponentType(JsonFactory factory, Logger logger, Map<String, Map<String, Object>> componentsMap, Class type, Type genericType) {
+        try {
+            Set<Type> types = new HashSet<>();
+            Encodeable encodeable = JsonFactory.root().loadEncoder(genericType);
+            String ct = componentKey(factory, logger, types, componentsMap, null, encodeable, true);
+            if (ct == null || ct.length() == 0) return null;
+            if (componentsMap.containsKey(ct)) return ct;
+            Map<String, Object> cmap = new LinkedHashMap<>();
+            componentsMap.put(ct, cmap); //必须在调用simpleSchemaType之前put，不然嵌套情况下死循环
+
+            cmap.put("type", "object");
+            List<String> requireds = new ArrayList<>();
+            Map<String, Object> properties = new LinkedHashMap<>();
+            if (encodeable instanceof ObjectEncoder) {
+                for (EnMember member : ((ObjectEncoder) encodeable).getMembers()) {
+                    Map<String, Object> schemaMap = new LinkedHashMap<>();
+                    simpleSchemaType(factory, logger, componentsMap, TypeToken.typeToClassOrElse(member.getEncoder().getType(), Object.class), member.getEncoder().getType(), schemaMap, true);
+                    String desc = "";
+                    if (member.getField() != null) {
+                        Column col = member.getField().getAnnotation(Column.class);
+                        if (col == null) {
+                            FilterColumn fcol = member.getField().getAnnotation(FilterColumn.class);
+                            if (fcol != null) {
+                                desc = fcol.comment();
+                                if (fcol.required()) requireds.add(member.getAttribute().field());
+                            }
+                        } else {
+                            desc = col.comment();
+                            if (!col.nullable()) requireds.add(member.getAttribute().field());
+                        }
+                        if (desc.isEmpty() && member.getField().getAnnotation(Comment.class) != null) {
+                            desc = member.getField().getAnnotation(Comment.class).value();
+                        }
+                    } else if (member.getMethod() != null) {
+                        Column col = member.getMethod().getAnnotation(Column.class);
+                        if (col == null) {
+                            FilterColumn fcol = member.getMethod().getAnnotation(FilterColumn.class);
+                            if (fcol != null) {
+                                desc = fcol.comment();
+                                if (fcol.required()) requireds.add(member.getAttribute().field());
+                            }
+                        } else {
+                            desc = col.comment();
+                            if (!col.nullable()) requireds.add(member.getAttribute().field());
+                        }
+                        if (desc.isEmpty() && member.getMethod().getAnnotation(Comment.class) != null) {
+                            desc = member.getMethod().getAnnotation(Comment.class).value();
+                        }
+                    }
+                    if (!desc.isEmpty()) schemaMap.put("description", desc);
+                    properties.put(member.getAttribute().field(), schemaMap);
+                }
+            }
+            if (!requireds.isEmpty()) cmap.put("required", requireds);
+            cmap.put("properties", properties);
+            return ct;
+        } catch (Exception e) {
+            logger.log(Level.WARNING, genericType + " generate component info error", e);
+            return null;
+        }
+    }
+
+    private static String componentKey(JsonFactory factory, Logger logger, Set<Type> types, Map<String, Map<String, Object>> componentsMap, EnMember field, Encodeable encodeable, boolean first) {
+        if (encodeable instanceof ObjectEncoder) {
+            if (types.contains(encodeable.getType())) return "";
+            types.add(encodeable.getType());
+            StringBuilder sb = new StringBuilder();
+            sb.append(((ObjectEncoder) encodeable).getTypeClass().getSimpleName());
+            for (EnMember member : ((ObjectEncoder) encodeable).getMembers()) {
+                if (member.getEncoder() instanceof ArrayEncoder
+                    || member.getEncoder() instanceof CollectionEncoder) {
+                    String subsb = componentKey(factory, logger, types, componentsMap, member, member.getEncoder(), false);
+                    if (subsb == null) return null;
+                    AccessibleObject real = member.getField() == null ? member.getMethod() : member.getField();
+                    if (real == null) continue;
+                    Class cz = real instanceof Field ? ((Field) real).getType() : ((Method) real).getReturnType();
+                    Type ct = real instanceof Field ? ((Field) real).getGenericType() : ((Method) real).getGenericReturnType();
+                    if (cz == ct) continue;
+                    if (field == null && encodeable.getType() instanceof Class) continue;
+                    if (sb.length() > 0 && subsb.length() > 0) sb.append("_");
+                    sb.append(subsb);
+                } else if (member.getEncoder() instanceof ObjectEncoder || member.getEncoder() instanceof SimpledCoder) {
+                    AccessibleObject real = member.getField() == null ? member.getMethod() : member.getField();
+                    if (real == null) continue;
+                    if (types.contains(member.getEncoder().getType())) continue;
+                    types.add(member.getEncoder().getType());
+                    if (member.getEncoder() instanceof SimpledCoder) {
+                        simpleSchemaType(factory, logger, componentsMap, ((SimpledCoder) member.getEncoder()).getType(), ((SimpledCoder) member.getEncoder()).getType(), new LinkedHashMap<>(), true);
+                    } else {
+                        simpleSchemaType(factory, logger, componentsMap, ((ObjectEncoder) member.getEncoder()).getTypeClass(), ((ObjectEncoder) member.getEncoder()).getType(), new LinkedHashMap<>(), true);
+                    }
+                    Class cz = real instanceof Field ? ((Field) real).getType() : ((Method) real).getReturnType();
+                    Type ct = real instanceof Field ? ((Field) real).getGenericType() : ((Method) real).getGenericReturnType();
+                    if (cz == ct) continue;
+                    String subsb = componentKey(factory, logger, types, componentsMap, member, member.getEncoder(), false);
+                    if (subsb == null) return null;
+                    if (field == null && member.getEncoder().getType() instanceof Class) continue;
+                    if (sb.length() > 0 && subsb.length() > 0) sb.append("_");
+                    sb.append(subsb);
+                } else if (member.getEncoder() instanceof MapEncoder) {
+                    continue;
+                } else {
+                    return null;
+                }
+            }
+            return sb.toString();
+        } else if (encodeable instanceof ArrayEncoder || encodeable instanceof CollectionEncoder) {
+            final boolean array = (encodeable instanceof ArrayEncoder);
+            Encodeable subEncodeable = array ? ((ArrayEncoder) encodeable).getComponentEncoder() : ((CollectionEncoder) encodeable).getComponentEncoder();
+            if (subEncodeable instanceof SimpledCoder && field != null) return "";
+            final String sb = componentKey(factory, logger, types, componentsMap, null, subEncodeable, false);
+            if (sb == null || sb.isEmpty()) return sb;
+            if (field != null && field.getField() != null && field.getField().getDeclaringClass() == Sheet.class) {
+                return sb;
+            }
+            return sb + (array ? "_Array" : "_Collection");
+        } else if (encodeable instanceof SimpledCoder) {
+            Class stype = ((SimpledCoder) encodeable).getType();
+            if (stype.isPrimitive() || stype == Boolean.class || Number.class.isAssignableFrom(stype) || CharSequence.class.isAssignableFrom(stype)) {
+                return stype.getSimpleName();
+            }
+            return "";
+        } else if (encodeable instanceof MapEncoder) {
+            return first ? null : "";
+        } else {
+            return null;
+        }
+    }
+
+    private static Object formatExample(JsonFactory factory, String example, Class type, Type genericType) {
+        if (example != null && !example.isEmpty()) return example;
+        JsonFactory jsonFactory = factory == null || factory == JsonFactory.root() ? exampleFactory : factory;
+        if (type == Flipper.class) {
+            return new Flipper();
+        } else if (TYPE_RETRESULT_OBJECT.equals(genericType)) {
+            return RetResult.success();
+        } else if (TYPE_RETRESULT_STRING.equals(genericType)) {
+            return RetResult.success();
+        } else if (TYPE_RETRESULT_INTEGER.equals(genericType)) {
+            return RetResult.success(0);
+        } else if (TYPE_RETRESULT_LONG.equals(genericType)) {
+            return RetResult.success(0L);
+        } else if (type == boolean.class || type == Boolean.class) {
+            return true;
+        } else if (type.isPrimitive()) {
+            return 0;
+        } else if (type == boolean[].class || type == Boolean[].class) {
+            return new boolean[]{true, false};
+        } else if (type == byte[].class || type == Byte[].class) {
+            return new byte[]{0, 0};
+        } else if (type == char[].class || type == Character[].class) {
+            return new char[]{'a', 'b'};
+        } else if (type == short[].class || type == Short[].class) {
+            return new short[]{0, 0};
+        } else if (type == int[].class || type == Integer[].class) {
+            return new int[]{0, 0};
+        } else if (type == long[].class || type == Long[].class) {
+            return new long[]{0, 0};
+        } else if (type == float[].class || type == Float[].class) {
+            return new float[]{0, 0};
+        } else if (type == double[].class || type == Double[].class) {
+            return new double[]{0, 0};
+        } else if (Number.class.isAssignableFrom(type)) {
+            return 0;
+        } else if (CharSequence.class.isAssignableFrom(type)) {
+            return "";
+        } else if (CompletableFuture.class.isAssignableFrom(type)) {
+            if (genericType instanceof ParameterizedType) {
+                try {
+                    ParameterizedType pt = (ParameterizedType) genericType;
+                    Type valType = pt.getActualTypeArguments()[0];
+                    return formatExample(factory, example, valType instanceof ParameterizedType ? (Class) ((ParameterizedType) valType).getRawType() : ((Class) valType), valType);
+                } catch (Throwable t) {
+                }
+            }
+        } else if (Sheet.class.isAssignableFrom(type)) { //要在Collection前面
+            if (genericType instanceof ParameterizedType) {
+                try {
+                    ParameterizedType pt = (ParameterizedType) genericType;
+                    Type valType = pt.getActualTypeArguments()[0];
+                    Class valClass = valType instanceof ParameterizedType ? (Class) ((ParameterizedType) valType).getRawType() : (Class) valType;
+                    Object val = formatExample(factory, example, valClass, valType);
+                    return new StringWrapper(jsonFactory.getConvert().convertTo(jsonFactory.getConvert().convertFrom(genericType, "{'rows':[" + val + "," + val + "]}")));
+                } catch (Throwable t) {
+                }
+            }
+        } else if (type.isArray()) {
+            try {
+                Object val = formatExample(factory, example, type.getComponentType(), type.getComponentType());
+                return new StringWrapper(jsonFactory.getConvert().convertTo(jsonFactory.getConvert().convertFrom(genericType, "[" + val + "," + val + "]")));
+            } catch (Throwable t) {
+            }
+        } else if (Collection.class.isAssignableFrom(type)) {
+            if (genericType instanceof ParameterizedType) {
+                try {
+                    ParameterizedType pt = (ParameterizedType) genericType;
+                    Type valType = pt.getActualTypeArguments()[0];
+                    Class valClass = valType instanceof ParameterizedType ? (Class) ((ParameterizedType) valType).getRawType() : (Class) valType;
+                    Object val = formatExample(factory, example, valClass, valType);
+                    return new StringWrapper(jsonFactory.getConvert().convertTo(jsonFactory.getConvert().convertFrom(genericType, "[" + val + "," + val + "]")));
+                } catch (Throwable t) {
+                }
+            }
+        } else if (type == RetResult.class) {
+            if (genericType instanceof ParameterizedType) {
+                try {
+                    ParameterizedType pt = (ParameterizedType) genericType;
+                    Type valType = pt.getActualTypeArguments()[0];
+                    Class valClass = valType instanceof ParameterizedType ? (Class) ((ParameterizedType) valType).getRawType() : (Class) valType;
+                    Object val = formatExample(factory, example, valClass, valType);
+                    return new StringWrapper(jsonFactory.getConvert().convertTo(jsonFactory.getConvert().convertFrom(genericType, "{'result':" + val + "}")));
+                } catch (Throwable t) {
+                }
+            }
+        } else if (type != void.class) {
+            try {
+                Decodeable decoder = jsonFactory.loadDecoder(genericType);
+                if (decoder instanceof ObjectDecoder) {
+                    StringBuilder json = new StringBuilder();
+                    json.append("{");
+                    int index = 0;
+                    for (DeMember member : ((ObjectDecoder) decoder).getMembers()) {
+                        if (!(member.getDecoder() instanceof ObjectDecoder)) continue;
+                        if (index > 0) json.append(",");
+                        json.append('"').append(member.getAttribute().field()).append("\":{}");
+                        index++;
+                    }
+                    json.append("}");
+                    Object val = jsonFactory.getConvert().convertFrom(genericType, json.toString());
+                    return new StringWrapper(jsonFactory.getConvert().convertTo(val));
+                }
+                Creator creator = Creator.create(type);
+                return new StringWrapper(jsonFactory.getConvert().convertTo(creator.create()));
+            } catch (Throwable t) {
+            }
+        }
+        return example;
+    }
+
+    private static final JsonFactory exampleFactory = JsonFactory.create().tiny(false);
+
+}

src/main/java/org/redkale/boot/ApplicationListener.java

@@ -43,6 +43,22 @@ public interface ApplicationListener {
     default void postStart(Application application) {
     }
 
+    /**
+     * Application 在运行Compile前调用
+     *
+     * @param application Application
+     */
+    default void preCompile(Application application) {
+    }
+
+    /**
+     * Application 在运行Compile后调用
+     *
+     * @param application Application
+     */
+    default void postCompile(Application application) {
+    }
+
     /**
      * Application 在运行shutdown前调用
      *

src/main/java/org/redkale/boot/ClassFilter.java

@@ -9,12 +9,14 @@ import java.io.*;
 import java.lang.annotation.*;
 import java.lang.reflect.Modifier;
 import java.net.*;
+import java.nio.charset.StandardCharsets;
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.function.Predicate;
 import java.util.jar.*;
 import java.util.logging.*;
 import java.util.regex.*;
+import javax.annotation.Priority;
 import org.redkale.util.*;
 import org.redkale.util.AnyValue.DefaultAnyValue;
 
@@ -63,11 +65,11 @@ public final class ClassFilter<T> {
 
     private final ClassLoader classLoader;
 
-    public ClassFilter(ClassLoader classLoader, Class<? extends Annotation> annotationClass, Class superClass, Class[] excludeSuperClasses) {
+    public ClassFilter(RedkaleClassLoader classLoader, Class<? extends Annotation> annotationClass, Class superClass, Class[] excludeSuperClasses) {
         this(classLoader, annotationClass, superClass, excludeSuperClasses, null);
     }
 
-    public ClassFilter(ClassLoader classLoader, Class<? extends Annotation> annotationClass, Class superClass, Class[] excludeSuperClasses, AnyValue conf) {
+    public ClassFilter(RedkaleClassLoader classLoader, Class<? extends Annotation> annotationClass, Class superClass, Class[] excludeSuperClasses, AnyValue conf) {
         this.annotationClass = annotationClass;
         this.superClass = superClass;
         this.excludeSuperClasses = excludeSuperClasses;
@@ -75,8 +77,8 @@ public final class ClassFilter<T> {
         this.classLoader = classLoader == null ? Thread.currentThread().getContextClassLoader() : classLoader;
     }
 
-    public static ClassFilter create(Class[] excludeSuperClasses, String includeregs, String excluderegs, Set<String> includeValues, Set<String> excludeValues) {
-        ClassFilter filter = new ClassFilter(null, null, null, excludeSuperClasses);
+    public static ClassFilter create(RedkaleClassLoader classLoader, Class[] excludeSuperClasses, String includeregs, String excluderegs, Set<String> includeValues, Set<String> excludeValues) {
+        ClassFilter filter = new ClassFilter(classLoader, null, null, excludeSuperClasses);
         filter.setIncludePatterns(includeregs == null ? null : includeregs.split(";"));
         filter.setExcludePatterns(excluderegs == null ? null : excluderegs.split(";"));
         filter.setPrivilegeIncludes(includeValues);
@@ -102,11 +104,12 @@ public final class ClassFilter<T> {
      * @return Set&lt;FilterEntry&lt;T&gt;&gt;
      */
     public final Set<FilterEntry<T>> getFilterEntrys() {
-        HashSet<FilterEntry<T>> set = new HashSet<>();
-        set.addAll(entrys);
-        if (ors != null) ors.forEach(f -> set.addAll(f.getFilterEntrys()));
-        if (ands != null) ands.forEach(f -> set.addAll(f.getFilterEntrys()));
-        return set;
+        List<FilterEntry<T>> list = new ArrayList<>();
+        list.addAll(entrys);
+        if (ors != null) ors.forEach(f -> list.addAll(f.getFilterEntrys()));
+        if (ands != null) ands.forEach(f -> list.addAll(f.getFilterEntrys()));
+        Collections.sort(list);
+        return new LinkedHashSet<>(list);
     }
 
     /**
@@ -115,11 +118,12 @@ public final class ClassFilter<T> {
      * @return Set&lt;FilterEntry&lt;T&gt;&gt;
      */
     public final Set<FilterEntry<T>> getFilterExpectEntrys() {
-        HashSet<FilterEntry<T>> set = new HashSet<>();
-        set.addAll(expectEntrys);
-        if (ors != null) ors.forEach(f -> set.addAll(f.getFilterExpectEntrys()));
-        if (ands != null) ands.forEach(f -> set.addAll(f.getFilterExpectEntrys()));
-        return set;
+        List<FilterEntry<T>> list = new ArrayList<>();
+        list.addAll(expectEntrys);
+        if (ors != null) ors.forEach(f -> list.addAll(f.getFilterExpectEntrys()));
+        if (ands != null) ands.forEach(f -> list.addAll(f.getFilterExpectEntrys()));
+        Collections.sort(list);
+        return new LinkedHashSet<>(list);
     }
 
     /**
@@ -128,7 +132,7 @@ public final class ClassFilter<T> {
      * @return Set&lt;FilterEntry&lt;T&gt;&gt;
      */
     public final Set<FilterEntry<T>> getAllFilterEntrys() {
-        HashSet<FilterEntry<T>> rs = new HashSet<>();
+        HashSet<FilterEntry<T>> rs = new LinkedHashSet<>();
         rs.addAll(getFilterEntrys());
         rs.addAll(getFilterExpectEntrys());
         return rs;
@@ -208,7 +212,7 @@ public final class ClassFilter<T> {
         } catch (Throwable cfe) {
             if (finest && !clazzname.startsWith("sun.") && !clazzname.startsWith("javax.")
                 && !clazzname.startsWith("com.sun.") && !clazzname.startsWith("jdk.") && !clazzname.startsWith("META-INF")
-                && !clazzname.startsWith("com.mysql.") && !clazzname.startsWith("com.microsoft.")
+                && !clazzname.startsWith("com.mysql.") && !clazzname.startsWith("com.microsoft.") && !clazzname.startsWith("freemarker.")
                 && !clazzname.startsWith("org.redkale") && (clazzname.contains("Service") || clazzname.contains("Servlet"))) {
                 //&& (!(cfe instanceof NoClassDefFoundError) || (cfe instanceof UnsupportedClassVersionError) || ((NoClassDefFoundError) cfe).getMessage().startsWith("java.lang.NoClassDefFoundError: java"))) {
                 logger.log(Level.FINEST, ClassFilter.class.getSimpleName() + " filter error for class: " + clazzname + (url == null ? "" : (" in " + url)), cfe);
@@ -383,7 +387,7 @@ public final class ClassFilter<T> {
      *
      * @param <T> 泛型
      */
-    public static final class FilterEntry<T> {
+    public static final class FilterEntry<T> implements Comparable<FilterEntry<T>> {
 
         private final HashSet<String> groups = new LinkedHashSet<>();
 
@@ -415,6 +419,14 @@ public final class ClassFilter<T> {
             this.name = property == null ? "" : property.getValue("name", "");
         }
 
+        @Override //@Priority值越大，优先级越高, 需要排前面
+        public int compareTo(FilterEntry o) {
+            if (!(o instanceof FilterEntry)) return 1;
+            Priority p1 = this.type.getAnnotation(Priority.class);
+            Priority p2 = ((FilterEntry<T>) o).type.getAnnotation(Priority.class);
+            return (p2 == null ? 0 : p2.value()) - (p1 == null ? 0 : p1.value());
+        }
+
         @Override
         public String toString() {
             return this.getClass().getSimpleName() + "[thread=" + Thread.currentThread().getName()
@@ -464,6 +476,7 @@ public final class ClassFilter<T> {
         public boolean isExpect() {
             return expect;
         }
+
     }
 
     /**
@@ -483,20 +496,20 @@ public final class ClassFilter<T> {
          * 加载当前线程的classpath扫描所有class进行过滤
          *
          * @param excludeFile 不需要扫描的文件夹， 可以为null
+         * @param loader      RedkaleClassloader， 不可为null
          * @param excludeRegs 包含此关键字的文件将被跳过， 可以为null
          * @param filters     过滤器
          *
          * @throws IOException 异常
          */
-        public static void load(final File excludeFile, final String[] excludeRegs, final ClassFilter... filters) throws IOException {
-            RedkaleClassLoader loader = (RedkaleClassLoader) Thread.currentThread().getContextClassLoader();
+        public static void load(final File excludeFile, RedkaleClassLoader loader, final String[] excludeRegs, final ClassFilter... filters) throws IOException {
             List<URL> urlfiles = new ArrayList<>(2);
             List<URL> urljares = new ArrayList<>(2);
             final URL exurl = excludeFile != null ? excludeFile.toURI().toURL() : null;
             final Pattern[] excludePatterns = toPattern(excludeRegs);
             for (URL url : loader.getAllURLs()) {
                 if (exurl != null && exurl.sameFile(url)) continue;
-                if (excludePatterns != null) {
+                if (excludePatterns != null && url != RedkaleClassLoader.URL_NONE) {
                     boolean skip = false;
                     for (Pattern p : excludePatterns) {
                         if (p.matcher(url.toString()).matches()) {
@@ -519,7 +532,7 @@ public final class ClassFilter<T> {
                 Set<String> classes = cache.get(url);
                 if (classes == null) {
                     classes = new LinkedHashSet<>();
-                    try (JarFile jar = new JarFile(URLDecoder.decode(url.getFile(), "UTF-8"))) {
+                    try (JarFile jar = new JarFile(URLDecoder.decode(url.getFile(), StandardCharsets.UTF_8))) {
                         Enumeration<JarEntry> it = jar.entries();
                         while (it.hasMoreElements()) {
                             String entryname = it.nextElement().getName().replace('/', '.');
@@ -527,6 +540,7 @@ public final class ClassFilter<T> {
                                 String classname = entryname.substring(0, entryname.length() - 6);
                                 if (classname.startsWith("javax.") || classname.startsWith("com.sun.")) continue;
                                 //常见的jar跳过
+                                if (classname.startsWith("com.redkaledyn.")) break; //redkale动态生成的类
                                 if (classname.startsWith("com.mysql.")) break;
                                 if (classname.startsWith("org.mariadb.")) break;
                                 if (classname.startsWith("oracle.jdbc.")) break;
@@ -553,17 +567,27 @@ public final class ClassFilter<T> {
                 Set<String> classes = cache.get(url);
                 if (classes == null) {
                     classes = new LinkedHashSet<>();
-                    files.clear();
-                    File root = new File(url.getFile());
-                    String rootpath = root.getPath();
-                    loadClassFiles(excludeFile, root, files);
-                    for (File f : files) {
-                        String classname = f.getPath().substring(rootpath.length() + 1, f.getPath().length() - 6).replace(File.separatorChar, '.');
-                        if (classname.startsWith("javax.") || classname.startsWith("com.sun.")) continue;
-                        classes.add(classname);
-                        if (debug) debugstr.append(classname).append("\r\n");
-                        for (final ClassFilter filter : filters) {
-                            if (filter != null) filter.filter(null, classname, url);
+                    final Set<String> cs = classes;
+                    if (url == RedkaleClassLoader.URL_NONE) loader.forEachCacheClass(v -> cs.add(v));
+                    if (cs.isEmpty()) {
+                        files.clear();
+                        File root = new File(url.getFile());
+                        String rootpath = root.getPath();
+                        loadClassFiles(excludeFile, root, files);
+                        for (File f : files) {
+                            String classname = f.getPath().substring(rootpath.length() + 1, f.getPath().length() - 6).replace(File.separatorChar, '.');
+                            if (classname.startsWith("javax.") || classname.startsWith("com.sun.")) continue;
+                            classes.add(classname);
+                            if (debug) debugstr.append(classname).append("\r\n");
+                            for (final ClassFilter filter : filters) {
+                                if (filter != null) filter.filter(null, classname, url);
+                            }
+                        }
+                    } else {
+                        for (String classname : classes) {
+                            for (final ClassFilter filter : filters) {
+                                if (filter != null) filter.filter(null, classname, url);
+                            }
                         }
                     }
                     cache.put(url, classes);

src/main/java/org/redkale/boot/LoggingBaseHandler.java

@@ -0,0 +1,20 @@
+/*
+ */
+package org.redkale.boot;
+
+import java.util.logging.Handler;
+
+/**
+ * Handler基类
+ * <p>
+ * 详情见: https://redkale.org
+ *
+ * @author zhangjx
+ * @since 2.7.0
+ */
+public abstract class LoggingBaseHandler extends Handler {
+
+    protected Application currentApplication() {
+        return Application.currentApplication; //不能直接暴露外界访问
+    }
+}

src/main/java/org/redkale/boot/LoggingFileHandler.java

@@ -5,16 +5,18 @@
  */
 package org.redkale.boot;
 
+import org.redkale.util.RedkaleClassLoader;
+
 import java.io.*;
 import java.nio.file.*;
 import static java.nio.file.StandardCopyOption.*;
-import java.time.*;
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 import java.util.logging.*;
 import java.util.logging.Formatter;
 import java.util.regex.Pattern;
+import org.redkale.util.*;
 
 /**
  * 自定义的日志输出类
@@ -24,12 +26,17 @@ import java.util.regex.Pattern;
  * @author zhangjx
  */
 @SuppressWarnings("unchecked")
-public class LogFileHandler extends Handler {
+public class LoggingFileHandler extends LoggingBaseHandler {
+
+    //public static final String FORMATTER_FORMAT = "%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS.%tL %4$s %2$s%n%5$s%6$s%n";
+    public static final String FORMATTER_FORMAT = "%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS.%tL %4$s %2$s\r\n%5$s%6$s\r\n";
+
+    static boolean traceflag = false; //防止设置system.property前调用Traces类导致enable提前初始化
 
     /**
      * SNCP的日志输出Handler
      */
-    public static class SncpLogFileHandler extends LogFileHandler {
+    public static class LoggingSncpFileHandler extends LoggingFileHandler {
 
         @Override
         public String getPrefix() {
@@ -37,16 +44,59 @@ public class LogFileHandler extends Handler {
         }
     }
 
+    public static class LoggingConsoleHandler extends ConsoleHandler {
+
+        private Pattern denyreg;
+
+        public LoggingConsoleHandler() {
+            super();
+            setFormatter(new LoggingFormater());
+            configure();
+        }
+
+        private void configure() {
+            LogManager manager = LogManager.getLogManager();
+            String denyregstr = manager.getProperty("java.util.logging.ConsoleHandler.denyreg");
+            try {
+                if (denyregstr != null && !denyregstr.trim().isEmpty()) {
+                    denyreg = Pattern.compile(denyregstr);
+                }
+            } catch (Exception e) {
+            }
+        }
+
+        @Override
+        public void publish(LogRecord log) {
+            if (denyreg != null && denyreg.matcher(log.getMessage()).find()) return;
+            if (traceflag && Traces.enable()) {
+                String traceid = Traces.currTraceid();
+                if (traceid == null || traceid.isEmpty()) {
+                    traceid = "[TID:N/A] ";
+                } else {
+                    traceid = "[TID:" + traceid + "] ";
+                }
+                if (log.getMessage() == null) {
+                    log.setMessage(traceid);
+                } else {
+                    log.setMessage(traceid + log.getMessage());
+                }
+            }
+            super.publish(log);
+        }
+    }
+
     /**
      * 默认的日志时间格式化类
+     * 与SimpleFormatter的区别在于level不使用本地化
      *
      */
     public static class LoggingFormater extends Formatter {
 
-        private static final String format = "%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS.%tL %4$s %2$s\r\n%5$s%6$s\r\n";
-
         @Override
         public String format(LogRecord log) {
+            if (log.getThrown() == null && log.getMessage() != null && log.getMessage().startsWith("------")) {
+                return formatMessage(log) + "\r\n";
+            }
             String source;
             if (log.getSourceClassName() != null) {
                 source = log.getSourceClassName();
@@ -71,7 +121,7 @@ public class LogFileHandler extends Handler {
                 pw.close();
                 throwable = sw.toString();
             }
-            return String.format(format,
+            return String.format(FORMATTER_FORMAT,
                 System.currentTimeMillis(),
                 source,
                 log.getLoggerName(),
@@ -79,14 +129,34 @@ public class LogFileHandler extends Handler {
                 message,
                 throwable);
         }
+    }
 
+    public static void initDebugLogConfig() {
+        try {
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            final PrintStream ps = new PrintStream(out);
+            ps.println("handlers = java.util.logging.ConsoleHandler");
+            ps.println(".level = FINEST");
+            ps.println("jdk.level = INFO");
+            ps.println("sun.level = INFO");
+            ps.println("com.sun.level = INFO");
+            ps.println("javax.level = INFO");
+            ps.println("java.util.logging.ConsoleHandler.level = FINEST");
+            ps.println("java.util.logging.ConsoleHandler.formatter = " + LoggingFileHandler.LoggingFormater.class.getName());
+            LogManager.getLogManager().readConfiguration(new ByteArrayInputStream(out.toByteArray()));
+        } catch (Exception e) {
+        }
     }
 
     protected final LinkedBlockingQueue<LogRecord> logqueue = new LinkedBlockingQueue();
 
-    private String pattern;
+    protected String pattern;
 
-    private String unusual; //不为null表示将 WARNING、SEVERE 级别的日志写入单独的文件中
+    protected String patternDateFormat; //需要时间格式化
+
+    protected String unusual; //不为null表示将 WARNING、SEVERE 级别的日志写入单独的文件中
+
+    protected String unusualDateFormat; //需要时间格式化
 
     private int limit;   //文件大小限制
 
@@ -98,9 +168,9 @@ public class LogFileHandler extends Handler {
 
     private long tomorrow;
 
-    private boolean append;
+    protected boolean append;
 
-    private Pattern denyreg;
+    protected Pattern denyreg;
 
     private final AtomicLong loglength = new AtomicLong();
 
@@ -114,7 +184,7 @@ public class LogFileHandler extends Handler {
 
     private OutputStream logunusualstream;
 
-    public LogFileHandler() {
+    public LoggingFileHandler() {
         updateTomorrow();
         configure();
         open();
@@ -178,16 +248,14 @@ public class LogFileHandler extends Handler {
                         }
                         if (logstream == null) {
                             logindex.incrementAndGet();
-                            java.time.LocalDate date = LocalDate.now();
-                            logfile = new File(pattern.replace("%m", String.valueOf((date.getYear() * 100 + date.getMonthValue()))).replace("%d", String.valueOf((date.getYear() * 10000 + date.getMonthValue() * 100 + date.getDayOfMonth()))));
+                            logfile = new File(patternDateFormat == null ? pattern : Utility.formatTime(patternDateFormat, -1, System.currentTimeMillis()));
                             logfile.getParentFile().mkdirs();
                             loglength.set(logfile.length());
                             logstream = new FileOutputStream(logfile, append);
                         }
                         if (unusual != null && logunusualstream == null) {
                             logunusualindex.incrementAndGet();
-                            java.time.LocalDate date = LocalDate.now();
-                            logunusualfile = new File(unusual.replace("%m", String.valueOf((date.getYear() * 100 + date.getMonthValue()))).replace("%d", String.valueOf((date.getYear() * 10000 + date.getMonthValue() * 100 + date.getDayOfMonth()))));
+                            logunusualfile = new File(unusualDateFormat == null ? unusual : Utility.formatTime(unusualDateFormat, -1, System.currentTimeMillis()));
                             logunusualfile.getParentFile().mkdirs();
                             logunusuallength.set(logunusualfile.length());
                             logunusualstream = new FileOutputStream(logunusualfile, append);
@@ -218,10 +286,10 @@ public class LogFileHandler extends Handler {
 
     private void configure() {
         LogManager manager = LogManager.getLogManager();
-        String cname = LogFileHandler.class.getName();
+        String cname = LoggingFileHandler.class.getName();
         this.pattern = manager.getProperty(cname + ".pattern");
         if (this.pattern == null) {
-            this.pattern = "logs-%m/" + getPrefix() + "log-%d.log";
+            this.pattern = "logs-%tm/" + getPrefix() + "log-%td.log";
         } else {
             int pos = this.pattern.lastIndexOf('/');
             if (pos > 0) {
@@ -230,6 +298,10 @@ public class LogFileHandler extends Handler {
                 this.pattern = getPrefix() + this.pattern;
             }
         }
+        if (this.pattern != null && this.pattern.contains("%")) { //需要时间格式化
+            this.patternDateFormat = this.pattern;
+            Utility.formatTime(this.patternDateFormat, -1, System.currentTimeMillis()); //测试时间格式是否正确
+        }
         String unusualstr = manager.getProperty(cname + ".unusual");
         if (unusualstr != null) {
             int pos = unusualstr.lastIndexOf('/');
@@ -239,6 +311,10 @@ public class LogFileHandler extends Handler {
                 this.unusual = getPrefix() + unusualstr;
             }
         }
+        if (this.unusual != null && this.unusual.contains("%")) { //需要时间格式化
+            this.unusualDateFormat = this.unusual;
+            Utility.formatTime(this.unusualDateFormat, -1, System.currentTimeMillis()); //测试时间格式是否正确
+        }
         String limitstr = manager.getProperty(cname + ".limit");
         try {
             if (limitstr != null) {
@@ -280,6 +356,7 @@ public class LogFileHandler extends Handler {
         try {
             if (filterstr != null) {
                 Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(filterstr);
+                RedkaleClassLoader.putReflectionDeclaredConstructors(clz, clz.getName());
                 setFilter((Filter) clz.getDeclaredConstructor().newInstance());
             }
         } catch (Exception e) {
@@ -288,6 +365,7 @@ public class LogFileHandler extends Handler {
         try {
             if (formatterstr != null) {
                 Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(formatterstr);
+                RedkaleClassLoader.putReflectionDeclaredConstructors(clz, clz.getName());
                 setFormatter((Formatter) clz.getDeclaredConstructor().newInstance());
             }
         } catch (Exception e) {
@@ -311,6 +389,7 @@ public class LogFileHandler extends Handler {
 
     @Override
     public void publish(LogRecord log) {
+        if (!isLoggable(log)) return;
         final String sourceClassName = log.getSourceClassName();
         if (sourceClassName == null || true) {
             StackTraceElement[] ses = new Throwable().getStackTrace();
@@ -324,6 +403,19 @@ public class LogFileHandler extends Handler {
             log.setSourceClassName('[' + Thread.currentThread().getName() + "] " + sourceClassName);
         }
         if (denyreg != null && denyreg.matcher(log.getMessage()).find()) return;
+        if (traceflag && Traces.enable()) {
+            String traceid = Traces.currTraceid();
+            if (traceid == null || traceid.isEmpty()) {
+                traceid = "[TID:N/A] ";
+            } else {
+                traceid = "[TID:" + traceid + "] ";
+            }
+            if (log.getMessage() == null) {
+                log.setMessage(traceid);
+            } else {
+                log.setMessage(traceid + log.getMessage());
+            }
+        }
         logqueue.offer(log);
     }
 

src/main/java/org/redkale/boot/LoggingSearchHandler.java

@@ -0,0 +1,303 @@
+/*
+ */
+package org.redkale.boot;
+
+import java.io.*;
+import java.util.*;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.*;
+import java.util.logging.Formatter;
+import java.util.regex.Pattern;
+import javax.persistence.*;
+import org.redkale.convert.*;
+import org.redkale.convert.json.JsonConvert;
+import org.redkale.source.*;
+import org.redkale.util.*;
+
+/**
+ * 基于SearchSource的日志输出类
+ * <p>
+ * 详情见: https://redkale.org
+ *
+ * @author zhangjx
+ * @since 2.7.0
+ */
+public class LoggingSearchHandler extends LoggingBaseHandler {
+
+    protected static final String DEFAULT_TABLE_NAME = "log-record";
+
+    protected final LinkedBlockingQueue<SearchLogRecord> logqueue = new LinkedBlockingQueue();
+
+    protected final AtomicInteger retryCount = new AtomicInteger(3);
+
+    protected String tag = DEFAULT_TABLE_NAME;  //用于表前缀， 默认是 
+
+    protected String tagDateFormat; //需要时间格式化
+
+    protected String pattern;
+
+    protected Pattern denyreg;
+
+    protected String sourceResourceName;
+
+    protected SearchSource source;
+
+    public LoggingSearchHandler() {
+        configure();
+        open();
+    }
+
+    private void open() {
+        final String name = "Redkale-" + getClass().getSimpleName() + "-Thread";
+        final int batchSize = 100; //批量最多100条
+        final List<SearchLogRecord> logList = new ArrayList<>();
+        final SimpleFormatter formatter = new SimpleFormatter();
+        final PrintStream outStream = System.out;
+        new Thread() {
+            {
+                setName(name);
+                setDaemon(true);
+            }
+
+            @Override
+            public void run() {
+                while (true) {
+                    try {
+                        SearchLogRecord log = logqueue.take();
+                        while (source == null && retryCount.get() > 0) initSource();
+                        //----------------------写日志-------------------------
+                        if (source == null) { //source加载失败
+                            outStream.print(formatter.format(log.rawLog));
+                        } else {
+                            logList.add(log);
+                            int size = batchSize;
+                            while (--size > 0) {
+                                log = logqueue.poll();
+                                if (log == null) break;
+                                logList.add(log);
+                            }
+                            source.insert(logList);
+                        }
+                    } catch (Exception e) {
+                        ErrorManager err = getErrorManager();
+                        if (err != null) err.error(null, e, ErrorManager.WRITE_FAILURE);
+                    } finally {
+                        logList.clear();
+                    }
+                }
+
+            }
+        }.start();
+    }
+
+    private synchronized void initSource() {
+        if (retryCount.get() < 1) return;
+        try {
+            Utility.sleep(3000); //如果SearchSource自身在打印日志，需要停顿一点时间让SearchSource初始化完成
+            Application application = currentApplication();
+            this.source = (SearchSource) application.loadDataSource(sourceResourceName, false);
+            if (retryCount.get() == 1 && this.source == null) System.err.println("ERROR: not load logging.source(" + sourceResourceName + ")");
+        } catch (Exception t) {
+            ErrorManager err = getErrorManager();
+            if (err != null) err.error(null, t, ErrorManager.WRITE_FAILURE);
+        } finally {
+            retryCount.decrementAndGet();
+        }
+    }
+
+    private static boolean checkTagName(String name) {  //只能是字母、数字、短横、点、%、$和下划线
+        if (name.isEmpty()) return false;
+        for (char ch : name.toCharArray()) {
+            if (ch >= '0' && ch <= '9') continue;
+            if (ch >= 'a' && ch <= 'z') continue;
+            if (ch >= 'A' && ch <= 'Z') continue;
+            if (ch == '_' || ch == '-' || ch == '%' || ch == '$' || ch == '.') continue;
+            return false;
+        }
+        return true;
+    }
+
+    private void configure() {
+        LogManager manager = LogManager.getLogManager();
+        String cname = getClass().getName();
+        this.sourceResourceName = manager.getProperty(cname + ".source");
+        if (this.sourceResourceName == null || this.sourceResourceName.isEmpty()) {
+            throw new RuntimeException("not found logging.property " + cname + ".source");
+        }
+        String tagstr = manager.getProperty(cname + ".tag");
+        if (tagstr != null && !tagstr.isEmpty()) {
+            if (!checkTagName(tagstr.replaceAll("\\$\\{.+\\}", ""))) throw new RuntimeException("found illegal logging.property " + cname + ".tag = " + tagstr);
+            this.tag = tagstr;
+            if (tagstr.contains("%")) {
+                this.tagDateFormat = this.tag;
+                Utility.formatTime(this.tagDateFormat, -1, System.currentTimeMillis()); //测试时间格式是否正确
+            }
+        }
+
+        String levelstr = manager.getProperty(cname + ".level");
+        try {
+            if (levelstr != null) {
+                Level l = Level.parse(levelstr);
+                setLevel(l != null ? l : Level.ALL);
+            }
+        } catch (Exception e) {
+        }
+        String filterstr = manager.getProperty(cname + ".filter");
+        try {
+            if (filterstr != null) {
+                Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(filterstr);
+                RedkaleClassLoader.putReflectionDeclaredConstructors(clz, clz.getName());
+                setFilter((Filter) clz.getDeclaredConstructor().newInstance());
+            }
+        } catch (Exception e) {
+        }
+        String formatterstr = manager.getProperty(cname + ".formatter");
+        try {
+            if (formatterstr != null) {
+                Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(formatterstr);
+                RedkaleClassLoader.putReflectionDeclaredConstructors(clz, clz.getName());
+                setFormatter((Formatter) clz.getDeclaredConstructor().newInstance());
+            }
+        } catch (Exception e) {
+        }
+        if (getFormatter() == null) setFormatter(new SimpleFormatter());
+
+        String encodingstr = manager.getProperty(cname + ".encoding");
+        try {
+            if (encodingstr != null) setEncoding(encodingstr);
+        } catch (Exception e) {
+        }
+
+        String denyregstr = manager.getProperty(cname + ".denyreg");
+        try {
+            if (denyregstr != null && !denyregstr.trim().isEmpty()) {
+                denyreg = Pattern.compile(denyregstr);
+            }
+        } catch (Exception e) {
+        }
+    }
+
+    @Override
+    public void publish(LogRecord log) {
+        if (!isLoggable(log)) return;
+        final String sourceClassName = log.getSourceClassName();
+        if (sourceClassName == null || true) {
+            StackTraceElement[] ses = new Throwable().getStackTrace();
+            for (int i = 2; i < ses.length; i++) {
+                if (ses[i].getClassName().startsWith("java.util.logging")) continue;
+                log.setSourceClassName(ses[i].getClassName());
+                log.setSourceMethodName(ses[i].getMethodName());
+                break;
+            }
+        }
+        if (denyreg != null && denyreg.matcher(log.getMessage()).find()) return;
+        String rawTag = tagDateFormat == null ? tag : Utility.formatTime(tagDateFormat, -1, log.getInstant().toEpochMilli());
+        logqueue.offer(new SearchLogRecord(rawTag, log));
+    }
+
+    @Override
+    public void flush() {
+    }
+
+    @Override
+    public void close() throws SecurityException {
+    }
+
+    @Entity
+    @Table(name = DEFAULT_TABLE_NAME)
+    @DistributeTable(strategy = SearchLogRecord.TableStrategy.class)
+    public static class SearchLogRecord {
+
+        @Id
+        @ConvertColumn(index = 1)
+        @SearchColumn(options = "false")
+        public String logid;
+
+        @ConvertColumn(index = 2)
+        @SearchColumn(options = "false")
+        public String level;
+
+        @ConvertColumn(index = 3)
+        @SearchColumn(date = true)
+        public long timestamp;
+
+        @ConvertColumn(index = 4)
+        @SearchColumn(options = "false")
+        public String traceid;
+
+        @ConvertColumn(index = 5)
+        public String threadName;
+
+        @ConvertColumn(index = 6)
+        @SearchColumn(text = true, options = "offsets")
+        public String loggerName;
+
+        @ConvertColumn(index = 7)
+        @SearchColumn(text = true, options = "offsets")
+        public String methodName;
+
+        @ConvertColumn(index = 8)
+        @SearchColumn(text = true, options = "offsets") //, analyzer = "ik_max_word"
+        public String message;  //log.message +"\r\n"+ log.thrown
+
+        @Transient
+        @ConvertDisabled
+        LogRecord rawLog;
+
+        @Transient
+        @ConvertDisabled
+        String rawTag;
+
+        public SearchLogRecord() {
+        }
+
+        protected SearchLogRecord(String tag, LogRecord log) {
+            this.rawLog = log;
+            this.rawTag = tag;
+            this.threadName = Thread.currentThread().getName();
+            this.traceid = LoggingFileHandler.traceflag ? Traces.currTraceid() : null;
+            String msg = log.getMessage();
+            if (log.getThrown() != null) {
+                StringWriter sw = new StringWriter();
+                PrintWriter pw = new PrintWriter(sw);
+                pw.println();
+                log.getThrown().printStackTrace(pw);
+                pw.close();
+                String throwable = sw.toString();
+                this.message = (msg != null && !msg.isEmpty()) ? (msg + "\r\n" + throwable) : throwable;
+            } else {
+                this.message = msg;
+            }
+            this.level = log.getLevel().toString();
+            this.loggerName = log.getLoggerName();
+            this.methodName = log.getSourceClassName() + " " + log.getSourceMethodName();
+            this.timestamp = log.getInstant().toEpochMilli();
+            this.logid = Utility.format36time(timestamp) + "_" + Utility.uuid();
+        }
+
+        @Override
+        public String toString() {
+            return JsonConvert.root().convertTo(this);
+        }
+
+        public static class TableStrategy implements DistributeTableStrategy<SearchLogRecord> {
+
+            @Override
+            public String getTable(String table, SearchLogRecord bean) {
+                return bean.rawTag;
+            }
+
+            @Override
+            public String getTable(String table, Serializable primary) {
+                throw new UnsupportedOperationException("Not supported yet.");
+            }
+
+            @Override
+            public String getTable(String table, FilterNode node) {
+                throw new UnsupportedOperationException("Not supported yet.");
+            }
+
+        }
+    }
+}

src/main/java/org/redkale/boot/NodeHttpServer.java

@@ -11,6 +11,7 @@ import java.net.*;
 import java.util.*;
 import java.util.concurrent.CountDownLatch;
 import java.util.logging.Level;
+import java.util.stream.Stream;
 import javax.annotation.*;
 import static org.redkale.boot.Application.RESNAME_SNCP_ADDR;
 import org.redkale.boot.ClassFilter.FilterEntry;
@@ -89,7 +90,7 @@ public class NodeHttpServer extends NodeServer {
 
     @Override
     protected void loadFilter(ClassFilter<? extends Filter> filterFilter, ClassFilter otherFilter) throws Exception {
-        if (httpServer != null) loadHttpFilter(this.serverConf.getAnyValue("filters"), filterFilter);
+        if (httpServer != null) loadHttpFilter(filterFilter);
     }
 
     @Override
@@ -101,19 +102,19 @@ public class NodeHttpServer extends NodeServer {
     private void initWebSocketService() {
         final NodeServer self = this;
         final ResourceFactory regFactory = application.getResourceFactory();
-        resourceFactory.register((ResourceFactory rf, final Object src, final String resourceName, Field field, Object attachment) -> { //主要用于单点的服务
+        resourceFactory.register((ResourceFactory rf, String srcResourceName, final Object srcObj, final String resourceName, Field field, Object attachment) -> { //主要用于单点的服务
             try {
                 if (field.getAnnotation(Resource.class) == null) return;
-                if (!(src instanceof WebSocketServlet)) return;
-                ResourceFactory.ResourceLoader loader = null;
+                if (!(srcObj instanceof WebSocketServlet)) return;
+                ResourceTypeLoader loader = null;
                 ResourceFactory sncpResFactory = null;
                 for (NodeServer ns : application.servers) {
                     if (!ns.isSNCP()) continue;
                     sncpResFactory = ns.resourceFactory;
-                    loader = sncpResFactory.findLoader(WebSocketNode.class, field);
+                    loader = sncpResFactory.findTypeLoader(WebSocketNode.class, field);
                     if (loader != null) break;
                 }
-                if (loader != null) loader.load(sncpResFactory, src, resourceName, field, attachment);
+                if (loader != null) loader.load(sncpResFactory, srcResourceName, srcObj, resourceName, field, attachment);
                 synchronized (regFactory) {
                     Service nodeService = (Service) rf.find(resourceName, WebSocketNode.class);
                     if (sncpResFactory != null && resourceFactory.find(RESNAME_SNCP_ADDR, String.class) == null) {
@@ -126,15 +127,15 @@ public class NodeHttpServer extends NodeServer {
                         try {
                             Field c = WebSocketServlet.class.getDeclaredField("messageAgent");
                             c.setAccessible(true);
-                            messageAgent = (MessageAgent) c.get(src);
+                            messageAgent = (MessageAgent) c.get(srcObj);
                         } catch (Exception ex) {
                             logger.log(Level.WARNING, "WebSocketServlet getMessageAgent error", ex);
                         }
-                        nodeService = Sncp.createLocalService(serverClassLoader, resourceName, WebSocketNodeService.class, messageAgent, application.getResourceFactory(), application.getSncpTransportFactory(), (InetSocketAddress) null, (Set<String>) null, (AnyValue) null);
+                        nodeService = Sncp.createLocalService(serverClassLoader, resourceName, org.redkale.net.http.WebSocketNodeService.class, messageAgent, application.getResourceFactory(), application.getSncpTransportFactory(), (InetSocketAddress) null, (Set<String>) null, (AnyValue) null);
                         regFactory.register(resourceName, WebSocketNode.class, nodeService);
                     }
-                    resourceFactory.inject(nodeService, self);
-                    field.set(src, nodeService);
+                    resourceFactory.inject(resourceName, nodeService, self);
+                    field.set(srcObj, nodeService);
                     logger.fine("[" + Thread.currentThread().getName() + "] Load Service " + nodeService);
                 }
             } catch (Exception e) {
@@ -144,13 +145,14 @@ public class NodeHttpServer extends NodeServer {
     }
 
     @SuppressWarnings("unchecked")
-    protected void loadHttpFilter(final AnyValue filtersConf, final ClassFilter<? extends Filter> classFilter) throws Exception {
+    protected void loadHttpFilter(final ClassFilter<? extends Filter> classFilter) throws Exception {
         final StringBuilder sb = logger.isLoggable(Level.INFO) ? new StringBuilder() : null;
         final String localThreadName = "[" + Thread.currentThread().getName() + "] ";
         List<FilterEntry<? extends Filter>> list = new ArrayList(classFilter.getFilterEntrys());
         for (FilterEntry<? extends Filter> en : list) {
             Class<HttpFilter> clazz = (Class<HttpFilter>) en.getType();
             if (Modifier.isAbstract(clazz.getModifiers())) continue;
+            RedkaleClassLoader.putReflectionDeclaredConstructors(clazz, clazz.getName());
             final HttpFilter filter = clazz.getDeclaredConstructor().newInstance();
             resourceFactory.inject(filter, this);
             DefaultAnyValue filterConf = (DefaultAnyValue) en.getProperty();
@@ -162,6 +164,9 @@ public class NodeHttpServer extends NodeServer {
 
     @SuppressWarnings("unchecked")
     protected void loadHttpServlet(final ClassFilter<? extends Servlet> servletFilter, ClassFilter<? extends WebSocket> webSocketFilter) throws Exception {
+        RedkaleClassLoader.putReflectionPublicClasses(HttpServlet.class.getName());
+        RedkaleClassLoader.putReflectionPublicClasses(HttpDispatcherServlet.class.getName());
+        RedkaleClassLoader.putReflectionDeclaredConstructors(HttpResourceServlet.class, HttpResourceServlet.class.getName());
         final AnyValue servletsConf = this.serverConf.getAnyValue("servlets");
         final StringBuilder sb = logger.isLoggable(Level.INFO) ? new StringBuilder() : null;
         String prefix0 = servletsConf == null ? "" : servletsConf.getValue("path", "");
@@ -181,16 +186,19 @@ public class NodeHttpServer extends NodeServer {
             }
             return ws1 ? -1 : 1;
         });
+        final long starts = System.currentTimeMillis();
         final List<AbstractMap.SimpleEntry<String, String[]>> ss = sb == null ? null : new ArrayList<>();
         for (FilterEntry<? extends Servlet> en : list) {
             Class<HttpServlet> clazz = (Class<HttpServlet>) en.getType();
             if (Modifier.isAbstract(clazz.getModifiers())) continue;
+            if (clazz.getAnnotation(Rest.RestDyn.class) != null) continue; //动态生成的跳过
             WebServlet ws = clazz.getAnnotation(WebServlet.class);
             if (ws == null) continue;
             if (ws.value().length == 0) {
                 logger.log(Level.INFO, "not found @WebServlet.value in " + clazz.getName());
                 continue;
             }
+            RedkaleClassLoader.putReflectionDeclaredConstructors(clazz, clazz.getName());
             final HttpServlet servlet = clazz.getDeclaredConstructor().newInstance();
             resourceFactory.inject(servlet, this);
             final String[] mappings = ws.value();
@@ -201,44 +209,96 @@ public class NodeHttpServer extends NodeServer {
                 for (int i = 0; i < mappings.length; i++) {
                     mappings[i] = pref + mappings[i];
                 }
-                ss.add(new AbstractMap.SimpleEntry<>(clazz.getName(), mappings));
+                ss.add(new AbstractMap.SimpleEntry<>("HttpServlet    (type=" + clazz.getName() + ")", mappings));
+            }
+        }
+        final List<AbstractMap.SimpleEntry<String, String[]>> rests = sb == null ? null : new ArrayList<>();
+        final List<AbstractMap.SimpleEntry<String, String[]>> webss = sb == null ? null : new ArrayList<>();
+        if (rest && serverConf != null) {
+            final List<Object> restedObjects = new ArrayList<>();
+            for (AnyValue restConf : serverConf.getAnyValues("rest")) {
+                loadRestServlet(webSocketFilter, restConf, restedObjects, sb, rests, webss);
             }
         }
         int max = 0;
         if (ss != null && sb != null) {
+            int maxTypeLength = 0;
+            int maxNameLength = 0;
+            if (rests != null) {
+                for (AbstractMap.SimpleEntry<String, String[]> en : rests) {
+                    int pos = en.getKey().indexOf('#');
+                    if (pos > maxTypeLength) maxTypeLength = pos;
+                    int len = en.getKey().length() - pos - 1;
+                    if (len > maxNameLength) maxNameLength = len;
+                }
+            }
+            if (webss != null) {
+                for (AbstractMap.SimpleEntry<String, String[]> en : webss) {
+                    int pos = en.getKey().indexOf('#');
+                    if (pos > maxTypeLength) maxTypeLength = pos;
+                    int len = en.getKey().length() - pos - 1;
+                    if (len > maxNameLength) maxNameLength = len;
+                }
+            }
+            if (rests != null) {
+                for (AbstractMap.SimpleEntry<String, String[]> en : rests) {
+                    StringBuilder sub = new StringBuilder();
+                    int pos = en.getKey().indexOf('#');
+                    sub.append("RestDynServlet (type=").append(en.getKey().substring(0, pos));
+                    for (int i = 0; i < maxTypeLength - pos; i++) {
+                        sub.append(' ');
+                    }
+                    sub.append(", name='").append(en.getKey().substring(pos + 1));
+                    for (int i = 0; i < maxNameLength - pos; i++) {
+                        sub.append(' ');
+                    }
+                    sub.append("')");
+                    ss.add(new AbstractMap.SimpleEntry<>(sub.toString(), en.getValue()));
+                }
+            }
+            if (webss != null) {
+                for (AbstractMap.SimpleEntry<String, String[]> en : webss) {
+                    StringBuilder sub = new StringBuilder();
+                    int pos = en.getKey().indexOf('#');
+                    sub.append("RestWebSocket  (type=").append(en.getKey().substring(0, pos));
+                    for (int i = 0; i < maxTypeLength - pos; i++) {
+                        sub.append(' ');
+                    }
+                    sub.append(", name='").append(en.getKey().substring(pos + 1));
+                    for (int i = 0; i < maxNameLength - pos; i++) {
+                        sub.append(' ');
+                    }
+                    sub.append("')");
+                    ss.add(new AbstractMap.SimpleEntry<>(sub.toString(), en.getValue()));
+                }
+            }
             ss.sort((AbstractMap.SimpleEntry<String, String[]> o1, AbstractMap.SimpleEntry<String, String[]> o2) -> o1.getKey().compareTo(o2.getKey()));
             for (AbstractMap.SimpleEntry<String, String[]> as : ss) {
                 if (as.getKey().length() > max) max = as.getKey().length();
             }
             for (AbstractMap.SimpleEntry<String, String[]> as : ss) {
-                sb.append(localThreadName).append(" Load ").append(as.getKey());
+                sb.append(localThreadName).append("Load ").append(as.getKey());
                 for (int i = 0; i < max - as.getKey().length(); i++) {
                     sb.append(' ');
                 }
                 sb.append("  mapping to  ").append(Arrays.toString(as.getValue())).append(LINE_SEPARATOR);
             }
-        }
-        if (rest && serverConf != null) {
-            final List<Object> restedObjects = new ArrayList<>();
-            for (AnyValue restConf : serverConf.getAnyValues("rest")) {
-                loadRestServlet(webSocketFilter, restConf, restedObjects, sb);
-            }
+            sb.append(localThreadName).append("All HttpServlets load cost ").append(System.currentTimeMillis() - starts).append(" ms").append(LINE_SEPARATOR);
         }
         if (sb != null && sb.length() > 0) logger.log(Level.INFO, sb.toString().trim());
     }
 
     @SuppressWarnings("unchecked")
-    protected void loadRestServlet(final ClassFilter<? extends WebSocket> webSocketFilter, final AnyValue restConf, final List<Object> restedObjects, final StringBuilder sb) throws Exception {
+    protected void loadRestServlet(final ClassFilter<? extends WebSocket> webSocketFilter, final AnyValue restConf, final List<Object> restedObjects, final StringBuilder sb,
+        final List<AbstractMap.SimpleEntry<String, String[]>> rests, final List<AbstractMap.SimpleEntry<String, String[]>> webss) throws Exception {
         if (!rest) return;
         if (restConf == null) return; //不存在REST服务
 
-        final long starts = System.currentTimeMillis();
         String prefix0 = restConf.getValue("path", "");
         if (!prefix0.isEmpty() && prefix0.charAt(prefix0.length() - 1) == '/') prefix0 = prefix0.substring(0, prefix0.length() - 1);
         if (!prefix0.isEmpty() && prefix0.charAt(0) != '/') prefix0 = '/' + prefix0;
 
         final String localThreadName = "[" + Thread.currentThread().getName() + "] ";
-        final List<AbstractMap.SimpleEntry<String, String[]>> ss = sb == null ? null : new ArrayList<>();
         String mqname = restConf.getValue("mq");
         MessageAgent agent0 = null;
         if (mqname != null) {
@@ -264,10 +324,11 @@ public class NodeHttpServer extends NodeServer {
                 }
             }
 
-            final ClassFilter restFilter = ClassFilter.create(null, restConf.getValue("includes", ""), restConf.getValue("excludes", ""), includeValues, excludeValues);
-            final boolean finest = logger.isLoggable(Level.FINEST);
+            final ClassFilter restFilter = ClassFilter.create(serverClassLoader, null, application.isCompileMode() ? "" : restConf.getValue("includes", ""), application.isCompileMode() ? "" : restConf.getValue("excludes", ""), includeValues, excludeValues);
             final CountDownLatch scdl = new CountDownLatch(super.interceptorServices.size());
-            super.interceptorServices.stream().parallel().forEach((service) -> {
+            Stream<Service> stream = super.interceptorServices.stream();
+            if (!application.isCompileMode()) stream = stream.parallel(); //不能并行，否则在maven plugin运行环境下ClassLoader不对
+            stream.forEach((service) -> {
                 try {
                     final Class stype = Sncp.getServiceType(service);
                     final String name = Sncp.getResourceName(service);
@@ -293,13 +354,13 @@ public class NodeHttpServer extends NodeServer {
                     dynServletMap.put(service, servlet);
                     if (messageAgent != null) messageAgent.putService(this, service, servlet);
                     //if (finest) logger.finest(localThreadName + " Create RestServlet(resource.name='" + name + "') = " + servlet);
-                    if (ss != null) {
+                    if (rests != null) {
                         String[] mappings = servlet.getClass().getAnnotation(WebServlet.class).value();
                         for (int i = 0; i < mappings.length; i++) {
                             mappings[i] = prefix2 + mappings[i];
                         }
-                        synchronized (ss) {
-                            ss.add(new AbstractMap.SimpleEntry<>(servlet.getClass().getName() + "(rest.name='" + name + "')", mappings));
+                        synchronized (rests) {
+                            rests.add(new AbstractMap.SimpleEntry<>(Sncp.getServiceType(service).getName() + "#" + name, mappings));
                         }
                     }
                 } finally {
@@ -318,8 +379,7 @@ public class NodeHttpServer extends NodeServer {
                     includeValues.add(item.getValue("value", ""));
                 }
             }
-
-            final ClassFilter restFilter = ClassFilter.create(null, restConf.getValue("includes", ""), restConf.getValue("excludes", ""), includeValues, excludeValues);
+            final ClassFilter restFilter = ClassFilter.create(serverClassLoader, null, application.isCompileMode() ? "" : restConf.getValue("includes", ""), application.isCompileMode() ? "" : restConf.getValue("excludes", ""), includeValues, excludeValues);
             final boolean finest = logger.isLoggable(Level.FINEST);
 
             List<FilterEntry<? extends WebSocket>> list = new ArrayList(webSocketFilter.getFilterEntrys());
@@ -334,56 +394,43 @@ public class NodeHttpServer extends NodeServer {
                     continue;
                 }
                 final Class<? extends WebSocket> stype = en.getType();
+                if (stype.getAnnotation(Rest.RestDyn.class) != null) continue;
                 RestWebSocket rs = stype.getAnnotation(RestWebSocket.class);
-                if (rs == null || rs.ignore()) return;
+                if (rs == null || rs.ignore()) continue;
 
                 final String stypename = stype.getName();
-                if (!autoload && !includeValues.contains(stypename)) return;
-                if (!restFilter.accept(stypename)) return;
+                if (!autoload && !includeValues.contains(stypename)) continue;
+                if (!restFilter.accept(stypename)) continue;
                 if (restedObjects.contains(stype)) {
                     logger.log(Level.WARNING, stype.getName() + " repeat create rest websocket, so ignore");
-                    return;
+                    continue;
                 }
                 restedObjects.add(stype); //避免重复创建Rest对象
                 WebSocketServlet servlet = httpServer.addRestWebSocketServlet(serverClassLoader, stype, messageAgent, prefix, en.getProperty());
-                if (servlet == null) return; //没有RestOnMessage方法的HttpServlet调用Rest.createRestWebSocketServlet就会返回null 
+                if (servlet == null) continue; //没有RestOnMessage方法的HttpServlet调用Rest.createRestWebSocketServlet就会返回null 
                 String prefix2 = prefix;
                 WebServlet ws = servlet.getClass().getAnnotation(WebServlet.class);
                 if (ws != null && !ws.repair()) prefix2 = "";
                 resourceFactory.inject(servlet, NodeHttpServer.this);
                 if (finest) logger.finest(localThreadName + " " + stype.getName() + " create a RestWebSocketServlet");
-                if (ss != null) {
+                if (webss != null) {
                     String[] mappings = servlet.getClass().getAnnotation(WebServlet.class).value();
                     for (int i = 0; i < mappings.length; i++) {
                         mappings[i] = prefix2 + mappings[i];
                     }
-                    ss.add(new AbstractMap.SimpleEntry<>(servlet.getClass().getName(), mappings));
+                    synchronized (webss) {
+                        webss.add(new AbstractMap.SimpleEntry<>(stype.getName() + "#" + rs.name(), mappings));
+                    }
                 }
             }
         }
         if (messageAgent != null) this.messageAgents.put(messageAgent.getName(), messageAgent);
-        //输出信息
-        if (ss != null && !ss.isEmpty() && sb != null) {
-            ss.sort((AbstractMap.SimpleEntry<String, String[]> o1, AbstractMap.SimpleEntry<String, String[]> o2) -> o1.getKey().compareTo(o2.getKey()));
-            int max = 0;
-            for (AbstractMap.SimpleEntry<String, String[]> as : ss) {
-                if (as.getKey().length() > max) max = as.getKey().length();
-            }
-            for (AbstractMap.SimpleEntry<String, String[]> as : ss) {
-                sb.append(localThreadName).append(" Load ").append(as.getKey());
-                for (int i = 0; i < max - as.getKey().length(); i++) {
-                    sb.append(' ');
-                }
-                sb.append("  mapping to  ").append(Arrays.toString(as.getValue())).append(LINE_SEPARATOR);
-            }
-            sb.append(localThreadName).append(" All HttpServlets load cost ").append(System.currentTimeMillis() - starts).append(" ms").append(LINE_SEPARATOR);
-        }
     }
 
     @Override //loadServlet执行之后调用
     protected void postLoadServlets() {
         final ClusterAgent cluster = application.clusterAgent;
-        if (cluster != null) {
+        if (!application.isCompileMode() && cluster != null) {
             NodeProtocol pros = getClass().getAnnotation(NodeProtocol.class);
             String protocol = pros.value().toUpperCase();
             if (!cluster.containsProtocol(protocol)) return;

src/main/java/org/redkale/boot/NodeServer.java

@@ -14,7 +14,6 @@ import java.lang.reflect.*;
 import java.net.*;
 import java.nio.file.*;
 import java.util.*;
-import java.util.AbstractMap.SimpleEntry;
 import java.util.concurrent.*;
 import java.util.function.*;
 import java.util.logging.*;
@@ -94,7 +93,7 @@ public abstract class NodeServer {
     //需要远程模式Service的MessageAgent对象集合
     protected final Map<String, MessageAgent> sncpRemoteAgents = new HashMap<>();
 
-    private volatile int maxClassNameLength = 0;
+    private volatile int maxTypeLength = 0;
 
     private volatile int maxNameLength = 0;
 
@@ -104,7 +103,11 @@ public abstract class NodeServer {
         this.server = server;
         this.resourceFactory = server.getResourceFactory();
         this.logger = Logger.getLogger(this.getClass().getSimpleName());
-        this.serverClassLoader = new RedkaleClassLoader(application.getServerClassLoader());
+        if (application.isCompileMode() || application.getServerClassLoader() instanceof RedkaleClassLoader.RedkaleCacheClassLoader) {
+            this.serverClassLoader = application.getServerClassLoader();
+        } else {
+            this.serverClassLoader = new RedkaleClassLoader(application.getServerClassLoader());
+        }
         Thread.currentThread().setContextClassLoader(this.serverClassLoader);
         this.serverThread = Thread.currentThread();
         this.server.setServerClassLoader(serverClassLoader);
@@ -112,7 +115,8 @@ public abstract class NodeServer {
 
     public static <T extends NodeServer> NodeServer create(Class<T> clazz, Application application, AnyValue serconf) {
         try {
-            return clazz.getConstructor(Application.class, AnyValue.class).newInstance(application, serconf);
+            RedkaleClassLoader.putReflectionDeclaredConstructors(clazz, clazz.getName(), Application.class, AnyValue.class);
+            return clazz.getDeclaredConstructor(Application.class, AnyValue.class).newInstance(application, serconf);
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
@@ -162,11 +166,12 @@ public abstract class NodeServer {
         String interceptorClass = this.serverConf.getValue("interceptor", "");
         if (!interceptorClass.isEmpty()) {
             Class clazz = serverClassLoader.loadClass(interceptorClass);
+            RedkaleClassLoader.putReflectionDeclaredConstructors(clazz, clazz.getName());
             this.interceptor = (NodeInterceptor) clazz.getDeclaredConstructor().newInstance();
         }
 
         ClassFilter<Service> serviceFilter = createServiceClassFilter();
-        if (application.singletonrun) { //singleton模式下只加载指定的Service
+        if (application.isSingletonMode()) { //singleton模式下只加载指定的Service
             final String ssc = System.getProperty("red" + "kale.singleton.serviceclass");
             final String extssc = System.getProperty("red" + "kale.singleton.extserviceclasses");
             if (ssc != null) {
@@ -184,11 +189,11 @@ public abstract class NodeServer {
         ClassFilter<Servlet> servletFilter = createServletClassFilter();
         ClassFilter otherFilter = createOtherClassFilter();
         long s = System.currentTimeMillis();
-        ClassFilter.Loader.load(application.getHome(), ((application.excludelibs != null ? (application.excludelibs + ";") : "") + serverConf.getValue("excludelibs", "")).split(";"), serviceFilter, filterFilter, servletFilter, otherFilter);
+        ClassFilter.Loader.load(application.getHome(), serverClassLoader, ((application.excludelibs != null ? (application.excludelibs + ";") : "") + serverConf.getValue("excludelibs", "")).split(";"), serviceFilter, filterFilter, servletFilter, otherFilter);
         long e = System.currentTimeMillis() - s;
         logger.info(this.getClass().getSimpleName() + " load filter class in " + e + " ms");
         loadService(serviceFilter, otherFilter); //必须在servlet之前
-        if (!application.singletonrun) { //非singleton模式下才加载Filter、Servlet
+        if (!application.isSingletonMode()) { //非singleton模式下才加载Filter、Servlet
             loadFilter(filterFilter, otherFilter);
             loadServlet(servletFilter, otherFilter);
             postLoadServlets();
@@ -206,54 +211,13 @@ public abstract class NodeServer {
         final ResourceFactory appResFactory = application.getResourceFactory();
         final TransportFactory appSncpTranFactory = application.getSncpTransportFactory();
         final AnyValue resources = application.config.getAnyValue("resources");
-        final Map<String, SimpleEntry<Class, AnyValue>> cacheResource = new HashMap<>();
-        final Map<String, SimpleEntry<Class, AnyValue>> dataResources = new HashMap<>();
-        if (resources != null) {
-            for (AnyValue sourceConf : resources.getAnyValues("source")) {
-                try {
-                    String classval = sourceConf.getValue("value");
-                    Class type = null;
-                    if (classval == null || classval.isEmpty()) {
-                        Iterator<CacheSource> it = ServiceLoader.load(CacheSource.class, serverClassLoader).iterator();
-                        while (it.hasNext()) {
-                            CacheSource s = it.next();
-                            if (s.match(sourceConf)) {
-                                type = s.getClass();
-                                break;
-                            }
-                        }
-                    } else {
-                        type = serverClassLoader.loadClass(classval);
-                    }
-                    if (type == DataSource.class) {
-                        type = DataMemorySource.class;
-                        for (AnyValue itemConf : sourceConf.getAnyValues("property")) {
-                            if (itemConf.getValue("name", "").contains(DataSources.JDBC_URL)) {
-                                type = DataJdbcSource.class;
-                                break;
-                            }
-                        }
-                    }
-                    if (!Service.class.isAssignableFrom(type)) {
-                        logger.log(Level.SEVERE, "load application source resource, but not Service error: " + sourceConf);
-                    } else if (CacheSource.class.isAssignableFrom(type)) {
-                        cacheResource.put(sourceConf.getValue("name", ""), new SimpleEntry(type, sourceConf));
-                    } else if (DataSource.class.isAssignableFrom(type)) {
-                        dataResources.put(sourceConf.getValue("name", ""), new SimpleEntry(type, sourceConf));
-                    } else {
-                        logger.log(Level.SEVERE, "load application source resource, but not CacheSource error: " + sourceConf);
-                    }
-                } catch (Exception e) {
-                    logger.log(Level.SEVERE, "load application source resource error: " + sourceConf, e);
-                }
-            }
-        }
+        final String confURI = appResFactory.find(RESNAME_APP_CONF_DIR, String.class);
         //------------------------------------- 注册 Resource --------------------------------------------------------
-        resourceFactory.register((ResourceFactory rf, final Object src, String resourceName, Field field, final Object attachment) -> {
+        resourceFactory.register((ResourceFactory rf, String srcResourceName, final Object srcObj, String resourceName, Field field, final Object attachment) -> {
             try {
                 Resource res = field.getAnnotation(Resource.class);
                 if (res == null || !res.name().startsWith("properties.")) return;
-                if ((src instanceof Service) && Sncp.isRemote((Service) src)) return; //远程模式不得注入 DataSource
+                if ((srcObj instanceof Service) && Sncp.isRemote((Service) srcObj)) return; //远程模式不得注入 DataSource
                 Class type = field.getType();
                 if (type != AnyValue.class && type != AnyValue[].class) return;
                 Object resource = null;
@@ -265,18 +229,18 @@ public abstract class NodeServer {
                     resource = properties.getAnyValues(res.name().substring("properties.".length()));
                     appResFactory.register(resourceName, AnyValue[].class, resource);
                 }
-                field.set(src, resource);
+                field.set(srcObj, resource);
             } catch (Exception e) {
                 logger.log(Level.SEVERE, "Resource inject error", e);
             }
         }, AnyValue.class, AnyValue[].class);
 
         //------------------------------------- 注册 Local AutoLoad(false) Service --------------------------------------------------------        
-        resourceFactory.register((ResourceFactory rf, final Object src, String resourceName, Field field, final Object attachment) -> {
+        resourceFactory.register((ResourceFactory rf, String srcResourceName, final Object srcObj, String resourceName, Field field, final Object attachment) -> {
             Class<Service> resServiceType = Service.class;
             try {
                 if (field.getAnnotation(Resource.class) == null) return;
-                if ((src instanceof Service) && Sncp.isRemote((Service) src)) return; //远程模式不得注入 AutoLoad Service
+                if ((srcObj instanceof Service) && Sncp.isRemote((Service) srcObj)) return; //远程模式不得注入 AutoLoad Service
                 if (!Service.class.isAssignableFrom(field.getType())) return;
                 resServiceType = (Class) field.getType();
                 if (resServiceType.getAnnotation(Local.class) == null) return;
@@ -284,120 +248,56 @@ public abstract class NodeServer {
                 if (al == null || al.value()) return;
 
                 //ResourceFactory resfactory = (isSNCP() ? appResFactory : resourceFactory);
-                SncpClient client = src instanceof Service ? Sncp.getSncpClient((Service) src) : null;
+                SncpClient client = srcObj instanceof Service ? Sncp.getSncpClient((Service) srcObj) : null;
                 final InetSocketAddress sncpAddr = client == null ? null : client.getClientAddress();
                 final Set<String> groups = new HashSet<>();
-                Service service = Sncp.createLocalService(serverClassLoader, resourceName, resServiceType, null, appResFactory, appSncpTranFactory, sncpAddr, groups, null);
+                Service service = Modifier.isFinal(resServiceType.getModifiers()) ? (Service) resServiceType.getConstructor().newInstance() : Sncp.createLocalService(serverClassLoader, resourceName, resServiceType, null, appResFactory, appSncpTranFactory, sncpAddr, groups, null);
                 appResFactory.register(resourceName, resServiceType, service);
 
-                field.set(src, service);
-                rf.inject(service, self); // 给其可能包含@Resource的字段赋值;
-                service.init(null);
-                logger.info("[" + Thread.currentThread().getName() + "] Load Service(@Local @AutoLoad) resourceName = " + resourceName + ", service = " + service);
+                field.set(srcObj, service);
+                rf.inject(resourceName, service, self); // 给其可能包含@Resource的字段赋值;
+                if (!application.isCompileMode()) service.init(null);
+                logger.info("[" + Thread.currentThread().getName() + "] Load Service(@Local @AutoLoad service = " + resServiceType.getSimpleName() + ", resourceName = '" + resourceName + "')");
             } catch (Exception e) {
-                logger.log(Level.SEVERE, "[" + Thread.currentThread().getName() + "] Load @Local @AutoLoad(false) Service inject " + resServiceType + " to " + src + " error", e);
+                logger.log(Level.SEVERE, "[" + Thread.currentThread().getName() + "] Load @Local @AutoLoad(false) Service inject " + resServiceType + " to " + srcObj + " error", e);
             }
         }, Service.class);
 
         //------------------------------------- 注册 DataSource --------------------------------------------------------        
-        resourceFactory.register((ResourceFactory rf, final Object src, String resourceName, Field field, final Object attachment) -> {
+        resourceFactory.register((ResourceFactory rf, String srcResourceName, final Object srcObj, String resourceName, Field field, final Object attachment) -> {
             try {
                 if (field.getAnnotation(Resource.class) == null) return;
-                if ((src instanceof Service) && Sncp.isRemote((Service) src)) return; //远程模式不得注入 DataSource
-                SimpleEntry<Class, AnyValue> resEntry = dataResources.get(resourceName);
-                AnyValue sourceConf = resEntry == null ? null : resEntry.getValue();
-                DataSource source = null;
-                if (sourceConf != null) {
-                    final Class sourceType = resEntry.getKey();
-                    if (sourceType == DataJdbcSource.class) {
-                        source = DataSources.createDataSource(resourceName, sourceConf);
-                    } else {
-                        boolean can = false;
-                        for (Constructor cr : sourceType.getConstructors()) {
-                            if (cr.getParameterCount() == 0) {
-                                can = true;
-                                break;
-                            }
-                        }
-                        if (DataSource.class.isAssignableFrom(sourceType) && can) { // 必须有空构造函数
-                            final Service srcService = (Service) src;
-                            SncpClient client = Sncp.getSncpClient(srcService);
-                            final InetSocketAddress sncpAddr = client == null ? null : client.getClientAddress();
-                            final Set<String> groups = new HashSet<>();
-                            source = (DataSource) Sncp.createLocalService(serverClassLoader, resourceName, sourceType, client == null ? null : client.getMessageAgent(), appResFactory, appSncpTranFactory, sncpAddr, groups, Sncp.getConf(srcService));
-                        }
-                    }
-                }
-                if (source == null) {
-                    source = DataSources.createDataSource(resourceName); //从persistence.xml配置中创建
-                }
-
-                application.dataSources.add(source);
-                appResFactory.register(resourceName, DataSource.class, source);
-
-                field.set(src, source);
-                rf.inject(source, self); // 给AsyncGroup和其他@Resource的字段赋值;
-                //NodeServer.this.watchFactory.inject(src);
-                if (source instanceof Service) ((Service) source).init(sourceConf);
+                if ((srcObj instanceof Service) && Sncp.isRemote((Service) srcObj)) return; //远程模式不得注入 DataSource
+                DataSource source = application.loadDataSource(resourceName, false);
+                field.set(srcObj, source);
             } catch (Exception e) {
-                logger.log(Level.SEVERE, "[" + Thread.currentThread().getName() + "] DataSource inject to " + src + " error", e);
+                logger.log(Level.SEVERE, "[" + Thread.currentThread().getName() + "] DataSource inject to " + srcObj + " error", e);
             }
         }, DataSource.class);
 
         //------------------------------------- 注册 CacheSource --------------------------------------------------------
-        resourceFactory.register(new ResourceFactory.ResourceLoader() {
+        resourceFactory.register(new ResourceTypeLoader() {
             @Override
-            public void load(ResourceFactory rf, final Object src, final String resourceName, Field field, final Object attachment) {
+            public void load(ResourceFactory rf, String srcResourceName, final Object srcObj, final String resourceName, Field field, final Object attachment) {
                 try {
                     if (field.getAnnotation(Resource.class) == null) return;
-                    if (!(src instanceof Service)) throw new RuntimeException("CacheSource must be inject in Service, cannot " + src);
-                    if ((src instanceof Service) && Sncp.isRemote((Service) src)) return; //远程模式不需要注入 CacheSource 
-                    final Service srcService = (Service) src;
+                    if (!(srcObj instanceof Service)) throw new RuntimeException("CacheSource must be inject in Service, cannot " + srcObj);
+                    if ((srcObj instanceof Service) && Sncp.isRemote((Service) srcObj)) return; //远程模式不需要注入 CacheSource 
+                    final Service srcService = (Service) srcObj;
                     SncpClient client = Sncp.getSncpClient(srcService);
                     final InetSocketAddress sncpAddr = client == null ? null : client.getClientAddress();
-                    SimpleEntry<Class, AnyValue> resEntry = cacheResource.get(resourceName);
-                    AnyValue sourceConf = resEntry == null ? null : resEntry.getValue();
-                    if (sourceConf == null) {
-                        SimpleEntry<Class, AnyValue> resEntry2 = dataResources.get(resourceName);
-                        sourceConf = resEntry2 == null ? null : resEntry2.getValue();
-                    }
-                    Class sourceType0 = CacheMemorySource.class;
-                    if (sourceConf != null) {
-                        String classval = sourceConf.getValue("value");
-                        if (classval == null || classval.isEmpty()) {
-                            Iterator<CacheSource> it = ServiceLoader.load(CacheSource.class, serverClassLoader).iterator();
-                            while (it.hasNext()) {
-                                CacheSource s = it.next();
-                                if (s.match(sourceConf)) {
-                                    sourceType0 = s.getClass();
-                                    break;
-                                }
-                            }
-                        } else {
-                            sourceType0 = serverClassLoader.loadClass(classval);
-                        }
-                    }
-                    final Class sourceType = sourceType0;
-                    Object source = null;
-                    if (CacheSource.class.isAssignableFrom(sourceType)) { // CacheSource
-                        source = Modifier.isFinal(sourceType.getModifiers()) ? sourceType.getConstructor().newInstance() : (CacheSource) Sncp.createLocalService(serverClassLoader, resourceName, sourceType, client == null ? null : client.getMessageAgent(), appResFactory, appSncpTranFactory, sncpAddr, null, Sncp.getConf(srcService));
-                        Type genericType = field.getGenericType();
-                        application.cacheSources.add((CacheSource) source);
-                        appResFactory.register(resourceName, CacheSource.class, source);
-                        if (genericType != CacheSource.class) {
-                            appResFactory.register(resourceName, genericType, source);
-                        }
-                    }
-                    field.set(src, source);
-                    rf.inject(source, self); //
-                    if (source instanceof Service) ((Service) source).init(sourceConf);
+                    final boolean ws = (srcObj instanceof org.redkale.net.http.WebSocketNodeService) && sncpAddr != null;
+                    CacheSource source = application.loadCacheSource(resourceName, ws);
+                    field.set(srcObj, source);
 
-                    if ((src instanceof WebSocketNodeService) && sncpAddr != null) { //只有WebSocketNodeService的服务才需要给SNCP服务注入CacheMemorySource
+                    if (ws) { //只有WebSocketNodeService的服务才需要给SNCP服务注入CacheMemorySource
                         NodeSncpServer sncpServer = application.findNodeSncpServer(sncpAddr);
-                        sncpServer.getSncpServer().addSncpServlet((Service) source);
+                        if (source != null && source.getClass().getAnnotation(Local.class) == null) { //本地模式的Service不生成SncpServlet
+                            sncpServer.getSncpServer().addSncpServlet((Service) source);
+                        }
                         //logger.info("[" + Thread.currentThread().getName() + "] Load Service " + source);
                     }
-                    logger.info("[" + Thread.currentThread().getName() + "] Load Source resourceName = " + resourceName + ", source = " + source);
+                    logger.info("[" + Thread.currentThread().getName() + "] Load CacheSource (type = " + (source == null ? null : source.getClass().getSimpleName()) + ", resourceName = '" + resourceName + "')");
                 } catch (Exception e) {
                     logger.log(Level.SEVERE, "DataSource inject error", e);
                 }
@@ -410,28 +310,28 @@ public abstract class NodeServer {
         }, CacheSource.class);
 
         //------------------------------------- 注册 WebSocketNode --------------------------------------------------------
-        resourceFactory.register(new ResourceFactory.ResourceLoader() {
+        resourceFactory.register(new ResourceTypeLoader() {
             @Override
-            public void load(ResourceFactory rf, final Object src, final String resourceName, Field field, final Object attachment) {
+            public void load(ResourceFactory rf, String srcResourceName, final Object srcObj, final String resourceName, Field field, final Object attachment) {
                 try {
                     if (field.getAnnotation(Resource.class) == null) return;
-                    if ((src instanceof Service) && Sncp.isRemote((Service) src)) return; //远程模式不需要注入 WebSocketNode 
+                    if ((srcObj instanceof Service) && Sncp.isRemote((Service) srcObj)) return; //远程模式不需要注入 WebSocketNode 
                     Service nodeService = (Service) rf.find(resourceName, WebSocketNode.class);
                     if (nodeService == null) {
                         final HashSet<String> groups = new HashSet<>();
                         if (groups.isEmpty() && isSNCP() && NodeServer.this.sncpGroup != null) groups.add(NodeServer.this.sncpGroup);
-                        nodeService = Sncp.createLocalService(serverClassLoader, resourceName, WebSocketNodeService.class, Sncp.getMessageAgent((Service) src), application.getResourceFactory(), application.getSncpTransportFactory(), NodeServer.this.sncpAddress, groups, (AnyValue) null);
+                        nodeService = Sncp.createLocalService(serverClassLoader, resourceName, org.redkale.net.http.WebSocketNodeService.class, Sncp.getMessageAgent((Service) srcObj), application.getResourceFactory(), application.getSncpTransportFactory(), NodeServer.this.sncpAddress, groups, (AnyValue) null);
                         (isSNCP() ? appResFactory : resourceFactory).register(resourceName, WebSocketNode.class, nodeService);
-                        ((WebSocketNodeService) nodeService).setName(resourceName);
+                        ((org.redkale.net.http.WebSocketNodeService) nodeService).setName(resourceName);
                     }
-                    resourceFactory.inject(nodeService, self);
-                    MessageAgent messageAgent = Sncp.getMessageAgent((Service) src);
+                    resourceFactory.inject(resourceName, nodeService, self);
+                    MessageAgent messageAgent = Sncp.getMessageAgent((Service) srcObj);
                     if (messageAgent != null && Sncp.getMessageAgent(nodeService) == null) Sncp.setMessageAgent(nodeService, messageAgent);
-                    field.set(src, nodeService);
+                    field.set(srcObj, nodeService);
                     if (Sncp.isRemote(nodeService)) {
                         remoteServices.add(nodeService);
                     } else {
-                        rf.inject(nodeService); //动态加载的Service也存在按需加载的注入资源
+                        rf.inject(resourceName, nodeService); //动态加载的Service也存在按需加载的注入资源
                         localServices.add(nodeService);
                         interceptorServices.add(nodeService);
                         if (consumer != null) consumer.accept(null, nodeService);
@@ -461,6 +361,7 @@ public abstract class NodeServer {
             final Class<? extends Service> serviceImplClass = entry.getType();
             if (Modifier.isFinal(serviceImplClass.getModifiers())) continue; //修饰final的类跳过
             if (!Modifier.isPublic(serviceImplClass.getModifiers())) continue;
+            if (serviceImplClass.getAnnotation(SncpDyn.class) != null) continue; //动态生成的跳过
             if (entry.isExpect()) {
                 if (Modifier.isAbstract(serviceImplClass.getModifiers())) continue; //修饰abstract的类跳过
                 if (DataSource.class.isAssignableFrom(serviceImplClass)) continue;
@@ -480,7 +381,7 @@ public abstract class NodeServer {
                 || (this.sncpGroup == null && entry.isEmptyGroups()) //空的SNCP配置
                 || serviceImplClass.getAnnotation(Local.class) != null;//本地模式
             if (localed && (serviceImplClass.isInterface() || Modifier.isAbstract(serviceImplClass.getModifiers()))) continue; //本地模式不能实例化接口和抽象类的Service类
-            final ResourceFactory.ResourceLoader resourceLoader = (ResourceFactory rf, final Object src, final String resourceName, Field field, final Object attachment) -> {
+            final ResourceTypeLoader resourceLoader = (ResourceFactory rf, String srcResourceName, final Object srcObj, final String resourceName, Field field, final Object attachment) -> {
                 try {
                     if (SncpClient.parseMethod(serviceImplClass).isEmpty() && serviceImplClass.getAnnotation(Priority.class) == null) {  //class没有可用的方法且没有标记启动优先级的， 通常为BaseService
                         if (!serviceImplClass.getName().startsWith("org.redkale.") && !serviceImplClass.getSimpleName().contains("Base")) {
@@ -488,7 +389,7 @@ public abstract class NodeServer {
                         }
                         return;
                     }
-
+                    RedkaleClassLoader.putReflectionPublicMethods(serviceImplClass.getName());
                     MessageAgent agent = null;
                     if (entry.getProperty() != null && entry.getProperty().getValue("mq") != null) {
                         agent = application.getMessageAgent(entry.getProperty().getValue("mq"));
@@ -496,14 +397,14 @@ public abstract class NodeServer {
                     }
 
                     Service service;
-                    final boolean ws = src instanceof WebSocketServlet;
+                    final boolean ws = srcObj instanceof WebSocketServlet;
                     if (ws || localed) { //本地模式
                         service = Sncp.createLocalService(serverClassLoader, resourceName, serviceImplClass, agent, appResourceFactory, appSncpTransFactory, NodeServer.this.sncpAddress, groups, entry.getProperty());
                     } else {
                         service = Sncp.createRemoteService(serverClassLoader, resourceName, serviceImplClass, agent, appSncpTransFactory, NodeServer.this.sncpAddress, groups, entry.getProperty());
                     }
-                    if (service instanceof WebSocketNodeService) {
-                        ((WebSocketNodeService) service).setName(resourceName);
+                    if (service instanceof org.redkale.net.http.WebSocketNodeService) {
+                        ((org.redkale.net.http.WebSocketNodeService) service).setName(resourceName);
                         if (agent != null) Sncp.setMessageAgent(service, agent);
                     }
                     final Class restype = Sncp.getResourceType(service);
@@ -516,7 +417,7 @@ public abstract class NodeServer {
                         remoteServices.add(service);
                         if (agent != null) sncpRemoteAgents.put(agent.getName(), agent);
                     } else {
-                        if (field != null) rf.inject(service); //动态加载的Service也存在按需加载的注入资源
+                        if (field != null) rf.inject(resourceName, service); //动态加载的Service也存在按需加载的注入资源
                         localServices.add(service);
                         interceptorServices.add(service);
                         if (consumer != null) consumer.accept(agent, service);
@@ -528,31 +429,33 @@ public abstract class NodeServer {
                 }
             };
             if (entry.isExpect()) {
-                ResourceType rty = entry.getType().getAnnotation(ResourceType.class);
-                resourceFactory.register(resourceLoader, rty == null ? entry.getType() : rty.value());
+                Class t = ResourceFactory.getResourceType(entry.getType());
+                if (resourceFactory.findResourceTypeLoader(t) == null) {
+                    resourceFactory.register(resourceLoader, t);
+                }
             } else {
-                resourceLoader.load(resourceFactory, null, entry.getName(), null, false);
+                resourceLoader.load(resourceFactory, null, null, entry.getName(), null, false);
             }
 
         }
-
+        long et = System.currentTimeMillis();
         application.servicecdl.countDown();
         application.servicecdl.await();
+        logger.info(this.getClass().getSimpleName() + " construct services in " + (et - starts) + " ms and await " + (System.currentTimeMillis() - et) + " ms");
 
         final StringBuilder sb = logger.isLoggable(Level.INFO) ? new StringBuilder() : null;
         //---------------- inject ----------------
         new ArrayList<>(localServices).forEach(y -> {
-            resourceFactory.inject(y, NodeServer.this);
-            calcMaxLength(y);
+            resourceFactory.inject(Sncp.getResourceName(y), y, NodeServer.this);
         });
         new ArrayList<>(remoteServices).forEach(y -> {
-            resourceFactory.inject(y, NodeServer.this);
+            resourceFactory.inject(Sncp.getResourceName(y), y, NodeServer.this);
             calcMaxLength(y);
         });
 
         if (sb != null) {
             remoteServices.forEach(y -> {
-                sb.append(localThreadName).append(Sncp.toSimpleString(y, maxNameLength, maxClassNameLength)).append(" load and inject").append(LINE_SEPARATOR);
+                sb.append(localThreadName).append(Sncp.toSimpleString(y, maxNameLength, maxTypeLength)).append(" load and inject").append(LINE_SEPARATOR);
             });
         }
         if (isSNCP() && !sncpRemoteAgents.isEmpty()) {
@@ -563,6 +466,7 @@ public abstract class NodeServer {
         }
         //----------------- init -----------------
         List<Service> swlist = new ArrayList<>(localServices);
+        swlist.forEach(y -> calcMaxLength(y));
         swlist.sort((o1, o2) -> {
             Priority p1 = o1.getClass().getAnnotation(Priority.class);
             Priority p2 = o2.getClass().getAnnotation(Priority.class);
@@ -579,13 +483,20 @@ public abstract class NodeServer {
         preInitServices(localServices, remoteServices);
         long preinite = System.currentTimeMillis() - preinits;
         final List<String> slist = sb == null ? null : new CopyOnWriteArrayList<>();
-        localServices.stream().forEach(y -> {
-            long s = System.currentTimeMillis();
-            y.init(Sncp.getConf(y));
-            long e = System.currentTimeMillis() - s;
-            String serstr = Sncp.toSimpleString(y, maxNameLength, maxClassNameLength);
-            if (slist != null) slist.add(new StringBuilder().append(localThreadName).append(serstr).append(" load and init in ").append(e).append(" ms").append(LINE_SEPARATOR).toString());
-        });
+        if (application.isCompileMode()) {
+            localServices.stream().forEach(y -> {
+                String serstr = Sncp.toSimpleString(y, maxNameLength, maxTypeLength);
+                if (slist != null) slist.add(new StringBuilder().append(localThreadName).append(serstr).append(" load").append(LINE_SEPARATOR).toString());
+            });
+        } else {
+            localServices.stream().forEach(y -> {
+                long s = System.currentTimeMillis();
+                y.init(Sncp.getConf(y));
+                long e = System.currentTimeMillis() - s;
+                String serstr = Sncp.toSimpleString(y, maxNameLength, maxTypeLength);
+                if (slist != null) slist.add(new StringBuilder().append(localThreadName).append(serstr).append(" load and init in ").append(e < 10 ? "  " : (e < 100 ? " " : "")).append(e).append(" ms").append(LINE_SEPARATOR).toString());
+            });
+        }
         if (slist != null && sb != null) {
             List<String> wlist = new ArrayList<>(slist); //直接使用CopyOnWriteArrayList偶尔会出现莫名的异常(CopyOnWriteArrayList源码1185行)
             for (String s : wlist) {
@@ -599,18 +510,19 @@ public abstract class NodeServer {
 
     private void calcMaxLength(Service y) { //计算toString中的长度
         maxNameLength = Math.max(maxNameLength, Sncp.getResourceName(y).length());
-        maxClassNameLength = Math.max(maxClassNameLength, Sncp.getResourceType(y).getName().length() + 1);
+        maxTypeLength = Math.max(maxTypeLength, Sncp.getResourceType(y).getName().length() + 1);
     }
 
     //Service.init执行之前调用
     protected void preInitServices(Set<Service> localServices, Set<Service> remoteServices) {
         final ClusterAgent cluster = application.clusterAgent;
-        if (cluster == null) return;
-        NodeProtocol pros = getClass().getAnnotation(NodeProtocol.class);
-        String protocol = pros.value().toUpperCase();
-        if (!cluster.containsProtocol(protocol)) return;
-        if (!cluster.containsPort(server.getSocketAddress().getPort())) return;
-        cluster.register(this, protocol, localServices, remoteServices);
+        if (!application.isCompileMode() && cluster != null) {
+            NodeProtocol pros = getClass().getAnnotation(NodeProtocol.class);
+            String protocol = pros.value().toUpperCase();
+            if (!cluster.containsProtocol(protocol)) return;
+            if (!cluster.containsPort(server.getSocketAddress().getPort())) return;
+            cluster.register(this, protocol, localServices, remoteServices);
+        }
     }
 
     //loadServlet执行之后调用
@@ -620,7 +532,7 @@ public abstract class NodeServer {
 
     //Service.destroy执行之前调用
     protected void preDestroyServices(Set<Service> localServices, Set<Service> remoteServices) {
-        if (application.clusterAgent != null) { //服务注销
+        if (!application.isCompileMode() && application.clusterAgent != null) { //服务注销
             final ClusterAgent cluster = application.clusterAgent;
             NodeProtocol pros = getClass().getAnnotation(NodeProtocol.class);
             String protocol = pros.value().toUpperCase();
@@ -629,7 +541,7 @@ public abstract class NodeServer {
                 afterClusterDeregisterOnPreDestroyServices(cluster, protocol);
             }
         }
-        if (!this.messageAgents.isEmpty()) { //MQ
+        if (!application.isCompileMode() && !this.messageAgents.isEmpty()) { //MQ
         }
     }
 
@@ -772,7 +684,7 @@ public abstract class NodeServer {
 
     public void start() throws IOException {
         if (interceptor != null) interceptor.preStart(this);
-        server.start(application);
+        server.start();
         postStartServer(localServices, remoteServices);
     }
 
@@ -788,16 +700,16 @@ public abstract class NodeServer {
             if (finest) logger.finest(y + " was destroyed");
             long e = System.currentTimeMillis() - s;
             if (e > 2 && sb != null) {
-                sb.append(Sncp.toSimpleString(y, maxNameLength, maxClassNameLength)).append(" destroy ").append(e).append("ms").append(LINE_SEPARATOR);
+                sb.append(Sncp.toSimpleString(y, maxNameLength, maxTypeLength)).append(" destroy ").append(e).append("ms").append(LINE_SEPARATOR);
             }
         });
         if (sb != null && sb.length() > 0) logger.log(Level.INFO, sb.toString());
         server.shutdown();
     }
 
-    public void command(String cmd) throws IOException {
+    public List<Object> command(String cmd, String[] params) throws IOException {
         final StringBuilder sb = logger.isLoggable(Level.INFO) ? new StringBuilder() : null;
-        final boolean finest = logger.isLoggable(Level.FINEST);
+        List<Object> results = new ArrayList<>();
         localServices.forEach(y -> {
             Set<Method> methods = new HashSet<>();
             Class loop = y.getClass();
@@ -805,10 +717,23 @@ public abstract class NodeServer {
             for (Method m : loop.getMethods()) {
                 Command c = m.getAnnotation(Command.class);
                 if (c == null) continue;
-                if (Modifier.isStatic(m.getModifiers())) continue;
-                if (m.getReturnType() != void.class) continue;
-                if (m.getParameterCount() != 1) continue;
-                if (m.getParameterTypes()[0] != String.class) continue;
+                if (Modifier.isStatic(m.getModifiers())) {
+                    logger.log(Level.WARNING, m + " is static on @Command");
+                    continue;
+                }
+                if (m.getParameterCount() != 1 && m.getParameterCount() != 2) {
+                    logger.log(Level.WARNING, m + " parameter count = " + m.getParameterCount() + " on @Command");
+                    continue;
+                }
+                if (m.getParameterTypes()[0] != String.class) {
+                    logger.log(Level.WARNING, m + " parameters[0] type is not String.class on @Command");
+                    continue;
+                }
+                if (m.getParameterCount() == 2 && m.getParameterTypes()[1] != String[].class) {
+                    logger.log(Level.WARNING, m + " parameters[1] type is not String[].class on @Command");
+                    continue;
+                }
+                if (!c.value().isEmpty() && !c.value().equalsIgnoreCase(cmd)) continue;
                 methods.add(m);
             }
             //} while ((loop = loop.getSuperclass()) != Object.class);
@@ -818,17 +743,19 @@ public abstract class NodeServer {
             try {
                 for (Method method : methods) {
                     one = method;
-                    method.invoke(y, cmd);
+                    Object r = method.getParameterCount() == 2 ? method.invoke(y, cmd, params) : method.invoke(y, cmd);
+                    if (r != null) results.add(r);
                 }
             } catch (Exception ex) {
                 logger.log(Level.SEVERE, one + " run error, cmd = " + cmd, ex);
             }
             long e = System.currentTimeMillis() - s;
             if (e > 10 && sb != null) {
-                sb.append(Sncp.toSimpleString(y, maxNameLength, maxClassNameLength)).append(" command (").append(cmd).append(") ").append(e).append("ms").append(LINE_SEPARATOR);
+                sb.append(Sncp.toSimpleString(y, maxNameLength, maxTypeLength)).append(" command (").append(cmd).append(") ").append(e).append("ms").append(LINE_SEPARATOR);
             }
         });
         if (sb != null && sb.length() > 0) logger.log(Level.INFO, sb.toString());
+        return results;
     }
 
     public <T extends Server> T getServer() {

src/main/java/org/redkale/boot/NodeSncpServer.java

@@ -33,8 +33,8 @@ public class NodeSncpServer extends NodeServer {
     private NodeSncpServer(Application application, AnyValue serconf) {
         super(application, createServer(application, serconf));
         this.sncpServer = (SncpServer) this.server;
-        this.consumer = sncpServer == null || application.singletonrun ? null : (agent, x) -> {//singleton模式下不生成SncpServlet
-            if (x.getClass().getAnnotation(Local.class) != null) return;
+        this.consumer = sncpServer == null || application.isSingletonMode() ? null : (agent, x) -> {//singleton模式下不生成SncpServlet
+            if (x.getClass().getAnnotation(Local.class) != null) return; //本地模式的Service不生成SncpServlet
             SncpDynServlet servlet = sncpServer.addSncpServlet(x);
             dynServletMap.put(x, servlet);
             if (agent != null) agent.putService(this, x, servlet);
@@ -95,6 +95,7 @@ public class NodeSncpServer extends NodeServer {
         for (FilterEntry<? extends Filter> en : list) {
             Class<SncpFilter> clazz = (Class<SncpFilter>) en.getType();
             if (Modifier.isAbstract(clazz.getModifiers())) continue;
+            RedkaleClassLoader.putReflectionDeclaredConstructors(clazz, clazz.getName());
             final SncpFilter filter = clazz.getDeclaredConstructor().newInstance();
             resourceFactory.inject(filter, this);
             DefaultAnyValue filterConf = (DefaultAnyValue) en.getProperty();
@@ -106,6 +107,8 @@ public class NodeSncpServer extends NodeServer {
 
     @Override
     protected void loadServlet(ClassFilter<? extends Servlet> servletFilter, ClassFilter otherFilter) throws Exception {
+        RedkaleClassLoader.putReflectionPublicClasses(SncpServlet.class.getName());
+        RedkaleClassLoader.putReflectionPublicClasses(SncpDynServlet.class.getName());
     }
 
     @Override

src/main/java/org/redkale/boot/PrepareCompiler.java

@@ -0,0 +1,86 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.redkale.boot;
+
+import java.lang.reflect.Modifier;
+import javax.persistence.Entity;
+import org.redkale.boot.ClassFilter.FilterEntry;
+import org.redkale.convert.Decodeable;
+import org.redkale.convert.bson.BsonFactory;
+import org.redkale.convert.json.*;
+import org.redkale.source.*;
+import org.redkale.util.*;
+
+/**
+ * 执行一次Application.run提前获取所有动态类
+ *
+ * @author zhangjx
+ * @since 2.5.0
+ */
+public class PrepareCompiler {
+
+//    public static void main(String[] args) throws Exception {
+//        new PrepareCompiler().run();
+//    }
+    public Application run() throws Exception {
+        final Application application = new Application(false, true, Application.loadAppConfig());
+        application.init();
+        for (ApplicationListener listener : application.listeners) {
+            listener.preStart(application);
+        }
+        for (ApplicationListener listener : application.listeners) {
+            listener.preCompile(application);
+        }
+        application.start();
+        final boolean hasSncp = application.getNodeServers().stream().filter(v -> v instanceof NodeSncpServer).findFirst().isPresent();
+        final String[] exlibs = (application.excludelibs != null ? (application.excludelibs + ";") : "").split(";");
+
+        final ClassFilter<?> entityFilter = new ClassFilter(application.getClassLoader(), Entity.class, Object.class, (Class[]) null);
+        final ClassFilter<?> beanFilter = new ClassFilter(application.getClassLoader(), Bean.class, Object.class, (Class[]) null);
+        final ClassFilter<?> filterFilter = new ClassFilter(application.getClassLoader(), null, FilterBean.class, (Class[]) null);
+
+        ClassFilter.Loader.load(application.getHome(), application.getClassLoader(), exlibs, entityFilter, beanFilter, filterFilter);
+
+        for (FilterEntry en : entityFilter.getFilterEntrys()) {
+            Class clz = en.getType();
+            if (clz.isInterface() || Modifier.isAbstract(clz.getModifiers())) continue;
+            try {
+                application.dataSources.forEach(source -> source.compile(clz));
+                JsonFactory.root().loadEncoder(clz);
+                if (hasSncp) BsonFactory.root().loadEncoder(clz);
+                Decodeable decoder = JsonFactory.root().loadDecoder(clz);
+                if (hasSncp) BsonFactory.root().loadDecoder(clz);
+                decoder.convertFrom(new JsonReader("{}"));
+            } catch (Exception e) { //JsonFactory.loadDecoder可能会失败，因为class可能包含抽象类字段,如ColumnValue.value字段
+            }
+        }
+        for (FilterEntry en : beanFilter.getFilterEntrys()) {
+            Class clz = en.getType();
+            if (clz.isInterface() || Modifier.isAbstract(clz.getModifiers())) continue;
+            try {
+                JsonFactory.root().loadEncoder(clz);
+                if (hasSncp) BsonFactory.root().loadEncoder(clz);
+                Decodeable decoder = JsonFactory.root().loadDecoder(clz);
+                if (hasSncp) BsonFactory.root().loadDecoder(clz);
+                decoder.convertFrom(new JsonReader("{}"));
+            } catch (Exception e) { //JsonFactory.loadDecoder可能会失败，因为class可能包含抽象类字段,如ColumnValue.value字段
+            }
+        }
+        for (FilterEntry en : filterFilter.getFilterEntrys()) {
+            Class clz = en.getType();
+            if (clz.isInterface() || Modifier.isAbstract(clz.getModifiers())) continue;
+            try {
+                FilterNodeBean.load(clz);
+            } catch (Exception e) {
+            }
+        }
+        for (ApplicationListener listener : application.listeners) {
+            listener.postCompile(application);
+        }
+        application.shutdown();
+        return application;
+    }
+}

src/main/java/org/redkale/boot/PropertiesAgent.java

@@ -0,0 +1,26 @@
+/*
+ */
+package org.redkale.boot;
+
+import java.util.Properties;
+import org.redkale.util.*;
+
+/**
+ * 配置源Agent, 在init方法内需要实现读取配置信息，如果支持配置更改通知，也需要在init里实现监听
+ *
+ *
+ * 详情见: https://redkale.org
+ *
+ * @author zhangjx
+ *
+ * @since 2.7.0
+ */
+public abstract class PropertiesAgent {
+
+    public void compile(AnyValue conf) {
+    }
+
+    public abstract void init(ResourceFactory factory, Properties appProperties, AnyValue conf);
+
+    public abstract void destroy(AnyValue conf);
+}

src/main/java/org/redkale/boot/watch/AbstractWatchService.java

@@ -15,9 +15,15 @@ import org.redkale.watch.WatchService;
  */
 public abstract class AbstractWatchService extends AbstractService implements WatchService {
 
+    /**
+     * 缺少参数
+     */
     @Comment("缺少参数")
     public static final int RET_WATCH_PARAMS_ILLEGAL = 1600_0001;
 
+    /**
+     * 执行异常
+     */
     @Comment("执行异常")
     public static final int RET_WATCH_RUN_EXCEPTION = 1600_0002;
 }

src/main/java/org/redkale/cluster/CacheClusterAgent.java

@@ -37,24 +37,26 @@ public class CacheClusterAgent extends ClusterAgent implements Resourcable {
 
     protected ScheduledThreadPoolExecutor scheduler;
 
-    //可能被HttpMessageClient用到的服务 key: servicename
+    //可能被HttpMessageClient用到的服务 key: serviceName
     protected final ConcurrentHashMap<String, Collection<InetSocketAddress>> httpAddressMap = new ConcurrentHashMap<>();
 
-    //可能被mqtp用到的服务 key: servicename
+    //可能被mqtp用到的服务 key: serviceName
     protected final ConcurrentHashMap<String, Collection<InetSocketAddress>> mqtpAddressMap = new ConcurrentHashMap<>();
 
     @Override
-    public void init(AnyValue config) {
-        super.init(config);
+    public void init(ResourceFactory factory, AnyValue config) {
+        super.init(factory, config);
+
         this.sourceName = getSourceName();
 
-        AnyValue[] properties = config.getAnyValues("property");
-        for (AnyValue property : properties) {
-            if ("ttls".equalsIgnoreCase(property.getValue("name"))) {
-                this.ttls = Integer.parseInt(property.getValue("value", "").trim());
-                if (this.ttls < 5) this.ttls = 10;
-            }
-        }
+        this.ttls = config.getIntValue("ttls", 10);
+        if (this.ttls < 5) this.ttls = 10;
+    }
+
+    @Override
+    public void setConfig(AnyValue config) {
+        super.setConfig(config);
+        this.sourceName = getSourceName();
     }
 
     @Override
@@ -63,15 +65,7 @@ public class CacheClusterAgent extends ClusterAgent implements Resourcable {
     }
 
     public String getSourceName() {
-        AnyValue[] properties = config.getAnyValues("property");
-        for (AnyValue property : properties) {
-            if ("source".equalsIgnoreCase(property.getValue("name"))
-                && property.getValue("value") != null) {
-                this.sourceName = property.getValue("value");
-                return this.sourceName;
-            }
-        }
-        return null;
+        return config.getValue("source");
     }
 
     @Override
@@ -80,15 +74,9 @@ public class CacheClusterAgent extends ClusterAgent implements Resourcable {
     }
 
     @Override //ServiceLoader时判断配置是否符合当前实现类
-    public boolean match(AnyValue config) {
+    public boolean acceptsConf(AnyValue config) {
         if (config == null) return false;
-        AnyValue[] properties = config.getAnyValues("property");
-        if (properties == null || properties.length == 0) return false;
-        for (AnyValue property : properties) {
-            if ("source".equalsIgnoreCase(property.getValue("name"))
-                && property.getValue("value") != null) return true;
-        }
-        return false;
+        return config.getValue("source") != null;
     }
 
     @Override
@@ -112,7 +100,7 @@ public class CacheClusterAgent extends ClusterAgent implements Resourcable {
                         updateSncpTransport(entry);
                     });
                 } catch (Exception e) {
-                    logger.log(Level.SEVERE, "scheduleAtFixedRate check error", e);
+                    logger.log(Level.SEVERE, "scheduleAtFixedRate check error", e instanceof CompletionException ? ((CompletionException) e).getCause() : e);
                 }
             }, Math.max(2000, ttls * 1000), Math.max(2000, ttls * 1000), TimeUnit.MILLISECONDS);
         }
@@ -120,22 +108,22 @@ public class CacheClusterAgent extends ClusterAgent implements Resourcable {
 
     protected void loadMqtpAddressHealth() {
         List<String> keys = source.queryKeysStartsWith("cluster.mqtp:");
-        keys.forEach(servicename -> {
+        keys.forEach(serviceName -> {
             try {
-                this.mqtpAddressMap.put(servicename, queryAddress(servicename).get(3, TimeUnit.SECONDS));
+                this.mqtpAddressMap.put(serviceName, queryAddress(serviceName).get(3, TimeUnit.SECONDS));
             } catch (Exception e) {
-                logger.log(Level.SEVERE, "loadMqtpAddressHealth check " + servicename + " error", e);
+                logger.log(Level.SEVERE, "loadMqtpAddressHealth check " + serviceName + " error", e);
             }
         });
     }
 
     protected void checkHttpAddressHealth() {
         try {
-            this.httpAddressMap.keySet().stream().forEach(servicename -> {
+            this.httpAddressMap.keySet().stream().forEach(serviceName -> {
                 try {
-                    this.httpAddressMap.put(servicename, queryAddress(servicename).get(3, TimeUnit.SECONDS));
+                    this.httpAddressMap.put(serviceName, queryAddress(serviceName).get(3, TimeUnit.SECONDS));
                 } catch (Exception e) {
-                    logger.log(Level.SEVERE, "checkHttpAddressHealth check " + servicename + " error", e);
+                    logger.log(Level.SEVERE, "checkHttpAddressHealth check " + serviceName + " error", e);
                 }
             });
         } catch (Exception ex) {
@@ -148,10 +136,10 @@ public class CacheClusterAgent extends ClusterAgent implements Resourcable {
         newaddr.addr = entry.address;
         newaddr.nodeid = this.nodeid;
         newaddr.time = System.currentTimeMillis();
-        source.hset(entry.checkname, entry.checkid, AddressEntry.class, newaddr);
+        source.hset(entry.checkName, entry.checkid, AddressEntry.class, newaddr);
     }
 
-    @Override //获取MQTP的HTTP远程服务的可用ip列表, key = servicename的后半段
+    @Override //获取MQTP的HTTP远程服务的可用ip列表, key = serviceName的后半段
     public CompletableFuture<Map<String, Collection<InetSocketAddress>>> queryMqtpAddress(String protocol, String module, String resname) {
         final Map<String, Collection<InetSocketAddress>> rsmap = new ConcurrentHashMap<>();
         final String servicenamprefix = generateHttpServiceName(protocol, module, null) + ":";
@@ -162,22 +150,22 @@ public class CacheClusterAgent extends ClusterAgent implements Resourcable {
 
     @Override //获取HTTP远程服务的可用ip列表
     public CompletableFuture<Collection<InetSocketAddress>> queryHttpAddress(String protocol, String module, String resname) {
-        final String servicename = generateHttpServiceName(protocol, module, resname);
-        Collection<InetSocketAddress> rs = httpAddressMap.get(servicename);
+        final String serviceName = generateHttpServiceName(protocol, module, resname);
+        Collection<InetSocketAddress> rs = httpAddressMap.get(serviceName);
         if (rs != null) return CompletableFuture.completedFuture(rs);
-        return queryAddress(servicename).thenApply(t -> {
-            httpAddressMap.put(servicename, t);
+        return queryAddress(serviceName).thenApply(t -> {
+            httpAddressMap.put(serviceName, t);
             return t;
         });
     }
 
     @Override
     protected CompletableFuture<Collection<InetSocketAddress>> queryAddress(final ClusterEntry entry) {
-        return queryAddress(entry.servicename);
+        return queryAddress(entry.serviceName);
     }
 
-    private CompletableFuture<Collection<InetSocketAddress>> queryAddress(final String servicename) {
-        final CompletableFuture<Map<String, AddressEntry>> future = source.hmapAsync(servicename, AddressEntry.class, 0, 10000);
+    private CompletableFuture<Collection<InetSocketAddress>> queryAddress(final String serviceName) {
+        final CompletableFuture<Map<String, AddressEntry>> future = source.hmapAsync(serviceName, AddressEntry.class, 0, 10000);
         return future.thenApply(map -> {
             final Set<InetSocketAddress> set = new HashSet<>();
             map.forEach((n, v) -> {
@@ -188,9 +176,9 @@ public class CacheClusterAgent extends ClusterAgent implements Resourcable {
     }
 
     protected boolean isApplicationHealth() {
-        String servicename = generateApplicationServiceName();
+        String serviceName = generateApplicationServiceName();
         String serviceid = generateApplicationServiceId();
-        AddressEntry entry = (AddressEntry) source.hget(servicename, serviceid, AddressEntry.class);
+        AddressEntry entry = (AddressEntry) source.hget(serviceName, serviceid, AddressEntry.class);
         return entry != null && (System.currentTimeMillis() - entry.time) / 1000 < ttls;
     }
 
@@ -210,18 +198,18 @@ public class CacheClusterAgent extends ClusterAgent implements Resourcable {
         deregister(application);
 
         String serviceid = generateApplicationServiceId();
-        String servicename = generateApplicationServiceName();
+        String serviceName = generateApplicationServiceName();
         AddressEntry entry = new AddressEntry();
         entry.addr = this.appAddress;
         entry.nodeid = this.nodeid;
         entry.time = System.currentTimeMillis();
-        source.hset(servicename, serviceid, AddressEntry.class, entry);
+        source.hset(serviceName, serviceid, AddressEntry.class, entry);
     }
 
     @Override
     public void deregister(Application application) {
-        String servicename = generateApplicationServiceName();
-        source.remove(servicename);
+        String serviceName = generateApplicationServiceName();
+        source.remove(serviceName);
     }
 
     @Override
@@ -233,7 +221,7 @@ public class CacheClusterAgent extends ClusterAgent implements Resourcable {
         entry.addr = clusterEntry.address;
         entry.nodeid = this.nodeid;
         entry.time = System.currentTimeMillis();
-        source.hset(clusterEntry.servicename, clusterEntry.serviceid, AddressEntry.class, entry);
+        source.hset(clusterEntry.serviceName, clusterEntry.serviceid, AddressEntry.class, entry);
         return clusterEntry;
     }
 
@@ -243,24 +231,24 @@ public class CacheClusterAgent extends ClusterAgent implements Resourcable {
     }
 
     protected void deregister(NodeServer ns, String protocol, Service service, boolean realcanceled) {
-        String servicename = generateServiceName(ns, protocol, service);
+        String serviceName = generateServiceName(ns, protocol, service);
         String serviceid = generateServiceId(ns, protocol, service);
         ClusterEntry currEntry = null;
         for (final ClusterEntry entry : localEntrys.values()) {
-            if (entry.servicename.equals(servicename) && entry.serviceid.equals(serviceid)) {
+            if (entry.serviceName.equals(serviceName) && entry.serviceid.equals(serviceid)) {
                 currEntry = entry;
                 break;
             }
         }
         if (currEntry == null) {
             for (final ClusterEntry entry : remoteEntrys.values()) {
-                if (entry.servicename.equals(servicename) && entry.serviceid.equals(serviceid)) {
+                if (entry.serviceName.equals(serviceName) && entry.serviceid.equals(serviceid)) {
                     currEntry = entry;
                     break;
                 }
             }
         }
-        source.hremove(servicename, serviceid);
+        source.hremove(serviceName, serviceid);
         if (realcanceled && currEntry != null) currEntry.canceled = true;
         if (!"mqtp".equals(protocol) && currEntry != null && currEntry.submqtp) {
             deregister(ns, "mqtp", service, realcanceled);

src/main/java/org/redkale/cluster/ClusterAgent.java

@@ -6,13 +6,15 @@
 package org.redkale.cluster;
 
 import java.lang.ref.WeakReference;
-import java.net.InetSocketAddress;
+import java.net.*;
+import java.nio.charset.StandardCharsets;
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.logging.Logger;
 import javax.annotation.Resource;
 import org.redkale.boot.*;
 import static org.redkale.boot.Application.*;
+import org.redkale.convert.ConvertDisabled;
 import org.redkale.convert.json.JsonConvert;
 import org.redkale.mq.MessageMultiConsumer;
 import org.redkale.net.*;
@@ -60,7 +62,7 @@ public abstract class ClusterAgent {
 
     protected final ConcurrentHashMap<String, ClusterEntry> remoteEntrys = new ConcurrentHashMap<>();
 
-    public void init(AnyValue config) {
+    public void init(ResourceFactory factory, AnyValue config) {
         this.config = config;
         this.name = config.getValue("name", "");
         this.waits = config.getBoolValue("waits", false);
@@ -85,7 +87,7 @@ public abstract class ClusterAgent {
     }
 
     //ServiceLoader时判断配置是否符合当前实现类
-    public abstract boolean match(AnyValue config);
+    public abstract boolean acceptsConf(AnyValue config);
 
     public boolean containsProtocol(String protocol) {
         if (protocol == null || protocol.isEmpty()) return false;
@@ -106,7 +108,7 @@ public abstract class ClusterAgent {
         if (localServices.isEmpty()) return;
         //注册本地模式
         for (Service service : localServices) {
-            if (!canRegister(protocol, service)) continue;
+            if (!canRegister(ns, protocol, service)) continue;
             ClusterEntry htentry = register(ns, protocol, service);
             localEntrys.put(htentry.serviceid, htentry);
             if (protocol.toLowerCase().startsWith("http")) {
@@ -132,19 +134,21 @@ public abstract class ClusterAgent {
     public void deregister(NodeServer ns, String protocol, Set<Service> localServices, Set<Service> remoteServices) {
         //注销本地模式  远程模式不注册
         for (Service service : localServices) {
-            if (!canRegister(protocol, service)) continue;
+            if (!canRegister(ns, protocol, service)) continue;
             deregister(ns, protocol, service);
         }
         afterDeregister(ns, protocol);
     }
 
-    protected boolean canRegister(String protocol, Service service) {
+    protected boolean canRegister(NodeServer ns, String protocol, Service service) {
         if ("SNCP".equalsIgnoreCase(protocol) && service.getClass().getAnnotation(Local.class) != null) return false;
         AutoLoad al = service.getClass().getAnnotation(AutoLoad.class);
         if (al != null && !al.value() && service.getClass().getAnnotation(Local.class) != null) return false;
         if (service instanceof WebSocketNode) {
             if (((WebSocketNode) service).getLocalWebSocketEngine() == null) return false;
         }
+        ClusterEntry entry = new ClusterEntry(ns, protocol, service);
+        if (entry.serviceName.trim().endsWith(serviceSeparator())) return false;
         return true;
     }
 
@@ -167,7 +171,7 @@ public abstract class ClusterAgent {
         return 10;
     }
 
-    //获取MQTP的HTTP远程服务的可用ip列表, key = servicename的后半段
+    //获取MQTP的HTTP远程服务的可用ip列表, key = serviceName的后半段
     public abstract CompletableFuture<Map<String, Collection<InetSocketAddress>>> queryMqtpAddress(String protocol, String module, String resname);
 
     //获取HTTP远程服务的可用ip列表
@@ -184,17 +188,25 @@ public abstract class ClusterAgent {
 
     //格式: protocol:classtype-resourcename
     protected void updateSncpTransport(ClusterEntry entry) {
-        Service service = entry.serviceref.get();
+        Service service = entry.serviceRef.get();
         if (service == null) return;
         Collection<InetSocketAddress> addrs = ClusterAgent.this.queryAddress(entry).join();
-        Sncp.updateTransport(service, transportFactory, Sncp.getResourceType(service).getName() + "-" + Sncp.getResourceName(service), entry.netprotocol, entry.address, null, addrs);
+        Sncp.updateTransport(service, transportFactory, Sncp.getResourceType(service).getName() + "-" + Sncp.getResourceName(service), entry.netProtocol, entry.address, null, addrs);
+    }
+
+    protected String urlEncode(String value) {
+        return value == null ? null : URLEncoder.encode(value, StandardCharsets.UTF_8);
     }
 
     protected String generateApplicationServiceName() {
-        return "application" + (appName == null || appName.isEmpty() ? "" : ("." + appName)) + ".node" + this.nodeid;
+        return "application" + (appName == null || appName.isEmpty() ? "" : ("." + appName)) + ".node." + this.nodeid;
     }
 
-    protected String generateApplicationServiceId() { //与servicename相同
+    protected String generateApplicationServiceType() {
+        return "application.nodes";
+    }
+
+    protected String generateApplicationServiceId() { //与serviceName相同
         return generateApplicationServiceName();
     }
 
@@ -206,9 +218,21 @@ public abstract class ClusterAgent {
         return "check-" + generateApplicationServiceId();
     }
 
+    protected String generateApplicationHost() {
+        return this.appAddress.getHostString();
+    }
+
+    protected int generateApplicationPort() {
+        return this.appAddress.getPort();
+    }
+
+    protected String serviceSeparator() {
+        return "-";
+    }
+
     //也会提供给HttpMessageClusterAgent适用
     public String generateHttpServiceName(String protocol, String module, String resname) {
-        return protocol.toLowerCase() + ":" + module + (resname == null || resname.isEmpty() ? "" : ("-" + resname));
+        return protocol.toLowerCase() + serviceSeparator() + module + (resname == null || resname.isEmpty() ? "" : ("-" + resname));
     }
 
     //格式: protocol:classtype-resourcename
@@ -216,21 +240,21 @@ public abstract class ClusterAgent {
         if (protocol.toLowerCase().startsWith("http")) {  //HTTP使用RestService.name方式是为了与MessageClient中的module保持一致, 因为HTTP依靠的url中的module，无法知道Service类名
             String resname = Sncp.getResourceName(service);
             String module = Rest.getRestModule(service).toLowerCase();
-            return protocol.toLowerCase() + ":" + module + (resname.isEmpty() ? "" : ("-" + resname));
+            return protocol.toLowerCase() + serviceSeparator() + module + (resname.isEmpty() ? "" : ("-" + resname));
         }
         if ("mqtp".equalsIgnoreCase(protocol)) {
             MessageMultiConsumer mmc = service.getClass().getAnnotation(MessageMultiConsumer.class);
             String selfmodule = Rest.getRestModule(service).toLowerCase();
-            return protocol.toLowerCase() + ":" + mmc.module() + ":" + selfmodule;
+            return protocol.toLowerCase() + serviceSeparator() + mmc.module() + serviceSeparator() + selfmodule;
         }
-        if (!Sncp.isSncpDyn(service)) return protocol.toLowerCase() + ":" + service.getClass().getName();
+        if (!Sncp.isSncpDyn(service)) return protocol.toLowerCase() + serviceSeparator() + service.getClass().getName();
         String resname = Sncp.getResourceName(service);
-        return protocol.toLowerCase() + ":" + Sncp.getResourceType(service).getName() + (resname.isEmpty() ? "" : ("-" + resname));
+        return protocol.toLowerCase() + serviceSeparator() + Sncp.getResourceType(service).getName() + (resname.isEmpty() ? "" : ("-" + resname));
     }
 
     //格式: protocol:classtype-resourcename:nodeid
     protected String generateServiceId(NodeServer ns, String protocol, Service service) {
-        return generateServiceName(ns, protocol, service) + ":" + this.nodeid;
+        return generateServiceName(ns, protocol, service) + serviceSeparator() + this.nodeid;
     }
 
     protected String generateCheckName(NodeServer ns, String protocol, Service service) {
@@ -249,11 +273,6 @@ public abstract class ClusterAgent {
         return remoteEntrys;
     }
 
-    @Override
-    public String toString() {
-        return JsonConvert.root().convertTo(this);
-    }
-
     public TransportFactory getTransportFactory() {
         return transportFactory;
     }
@@ -296,19 +315,26 @@ public abstract class ClusterAgent {
 
     public class ClusterEntry {
 
+        //serviceName+nodeid为主  服务的单个实例
         public String serviceid;
 
-        public String servicename;
+        //以协议+Rest资源名为主  服务类名
+        public String serviceName;
+
+        public String serviceType;
 
         public String checkid;
 
-        public String checkname;
+        public String checkName;
 
+        //http or sncp or mqtp
         public String protocol;
 
-        public String netprotocol;
+        //TCP or UDP
+        public String netProtocol;
 
-        public WeakReference<Service> serviceref;
+        @ConvertDisabled
+        public WeakReference<Service> serviceRef;
 
         public InetSocketAddress address;
 
@@ -318,9 +344,10 @@ public abstract class ClusterAgent {
 
         public ClusterEntry(NodeServer ns, String protocol, Service service) {
             this.serviceid = generateServiceId(ns, protocol, service);
-            this.servicename = generateServiceName(ns, protocol, service);
+            this.serviceName = generateServiceName(ns, protocol, service);
             this.checkid = generateCheckId(ns, protocol, service);
-            this.checkname = generateCheckName(ns, protocol, service);
+            this.checkName = generateCheckName(ns, protocol, service);
+            this.serviceType = Sncp.getServiceType(service).getName();
             this.protocol = protocol;
             InetSocketAddress addr = ns.getSocketAddress();
             String host = addr.getHostString();
@@ -329,9 +356,9 @@ public abstract class ClusterAgent {
                 addr = new InetSocketAddress(host, addr.getPort());
             }
             this.address = addr;
-            this.serviceref = new WeakReference(service);
+            this.serviceRef = new WeakReference(service);
             Server server = ns.getServer();
-            this.netprotocol = server instanceof SncpServer ? ((SncpServer) server).getNetprotocol() : Transport.DEFAULT_NETPROTOCOL;
+            this.netProtocol = server instanceof SncpServer ? ((SncpServer) server).getNetprotocol() : Transport.DEFAULT_NETPROTOCOL;
         }
 
         @Override

src/main/java/org/redkale/cluster/ClusterAgentProvider.java

@@ -0,0 +1,25 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.redkale.cluster;
+
+import org.redkale.util.AnyValue;
+
+/**
+ * 自定义的ClusterAgent加载器
+ *
+ *
+ * <p>
+ * 详情见: https://redkale.org
+ *
+ * @author zhangjx
+ * @since 2.5.0
+ */
+public interface ClusterAgentProvider {
+
+    public boolean acceptsConf(AnyValue config);
+
+    public Class<? extends ClusterAgent> agentClass();
+}

src/main/java/org/redkale/convert/AnyDecoder.java

@@ -14,7 +14,7 @@ import static org.redkale.convert.Reader.ValueType.MAP;
 /**
  * 对不明类型的对象进行反序列化。 <br>
  * <b>注意: 目前只支持文本格式</b> <br>
- * <p>
+ *
  * 详情见: https://redkale.org
  *
  * @author zhangjx
@@ -31,12 +31,17 @@ public class AnyDecoder implements Decodeable<Reader, Object> {
 
     private static final Creator<HashMap> mapCreator = Creator.create(HashMap.class);
 
-    protected final Decodeable<Reader, String> stringDecoder;
+    final Decodeable<Reader, String> stringDecoder;
 
-    protected final CollectionDecoder collectionDecoder;
+    final CollectionDecoder collectionDecoder;
 
-    protected final MapDecoder mapDecoder;
+    final MapDecoder mapDecoder;
 
+    /**
+     * 构造函数
+     *
+     * @param factory ConvertFactory
+     */
     public AnyDecoder(final ConvertFactory factory) {
         this.stringDecoder = factory.loadDecoder(String.class);
         this.collectionDecoder = new CollectionDecoder(factory, collectionObjectType, Object.class, collectionCreator, this);

src/main/java/org/redkale/convert/AnyEncoder.java

@@ -0,0 +1,53 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.redkale.convert;
+
+import java.lang.reflect.Type;
+
+/**
+ * 对不明类型的对象进行序列化； BSON序列化时将对象的类名写入Writer，JSON则不写入。
+ *
+ * 详情见: https://redkale.org
+ *
+ * @author zhangjx
+ * @param <T> 序列化的泛型类型
+ */
+public final class AnyEncoder<T> implements Encodeable<Writer, T> {
+
+    final ConvertFactory factory;
+
+    AnyEncoder(ConvertFactory factory) {
+        this.factory = factory;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void convertTo(final Writer out, final T value) {
+        if (value == null) {
+            out.writeClassName(null);
+            out.writeNull();
+        } else {
+            Class clazz = value.getClass();
+            if (clazz == Object.class) {
+                out.writeObjectB(value);
+                out.writeObjectE(value);
+                return;
+            }
+            if (out.needWriteClassName()) out.writeClassName(factory.getEntityAlias(clazz));
+            factory.loadEncoder(clazz).convertTo(out, value);
+        }
+    }
+
+    @Override
+    public Type getType() {
+        return Object.class;
+    }
+
+    @Override
+    public boolean specifyable() {
+        return false;
+    }
+}

src/main/java/org/redkale/convert/AnyValueDecoder.java

@@ -0,0 +1,40 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.redkale.convert;
+
+import java.lang.reflect.Type;
+import org.redkale.util.AnyValue;
+
+/**
+ * AnyValue的Decoder实现
+ *
+ * <p>
+ * 详情见: https://redkale.org
+ *
+ * @author zhangjx
+ * @param <R> Reader输入的子类型
+ *
+ * @since 2.5.0
+ */
+public class AnyValueDecoder<R extends Reader> implements Decodeable<R, AnyValue> {
+
+    protected final ConvertFactory factory;
+
+    public AnyValueDecoder(final ConvertFactory factory) {
+        this.factory = factory;
+    }
+
+    @Override
+    public AnyValue convertFrom(R in) {
+        return null;
+    }
+
+    @Override
+    public Type getType() {
+        return AnyValue.class;
+    }
+
+}

src/main/java/org/redkale/convert/AnyValueEncoder.java

@@ -0,0 +1,33 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.redkale.convert;
+
+import java.lang.reflect.Type;
+import org.redkale.util.AnyValue;
+
+/**
+ * AnyValue的Encoder实现
+ *
+ * <p>
+ * 详情见: https://redkale.org
+ *
+ * @author zhangjx
+ * @param <W> Writer输出的子类
+ *
+ * @since 2.5.0
+ */
+public class AnyValueEncoder<W extends Writer> implements Encodeable<W, AnyValue> {
+
+    @Override
+    public void convertTo(W out, AnyValue value) {
+    }
+
+    @Override
+    public Type getType() {
+        return AnyValue.class;
+    }
+
+}

src/main/java/org/redkale/convert/ArrayDecoder.java

@@ -7,6 +7,8 @@ package org.redkale.convert;
 
 import java.lang.reflect.*;
 import java.util.*;
+import java.util.function.IntFunction;
+import org.redkale.util.Creator;
 
 /**
  * 数组的反序列化操作类  <br>
@@ -30,6 +32,8 @@ public class ArrayDecoder<T> implements Decodeable<Reader, T[]> {
 
     protected final Decodeable<Reader, T> componentDecoder;
 
+    protected final IntFunction<T[]> componentArrayFunction;
+
     protected volatile boolean inited = false;
 
     protected final Object lock = new Object();
@@ -52,6 +56,7 @@ public class ArrayDecoder<T> implements Decodeable<Reader, T[]> {
             }
             factory.register(type, this);
             this.componentDecoder = factory.loadDecoder(this.componentType);
+            this.componentArrayFunction = Creator.arrayFunction(this.componentClass);
         } finally {
             inited = true;
             synchronized (lock) {
@@ -102,7 +107,7 @@ public class ArrayDecoder<T> implements Decodeable<Reader, T[]> {
             }
         }
         in.readArrayE();
-        T[] rs = (T[]) Array.newInstance((Class) this.componentClass, result.size());
+        T[] rs = this.componentArrayFunction.apply(result.size());
         return result.toArray(rs);
     }
 

src/main/java/org/redkale/convert/ArrayEncoder.java

@@ -29,7 +29,7 @@ public class ArrayEncoder<T> implements Encodeable<Writer, T[]> {
 
     protected final Encodeable<Writer, Object> componentEncoder;
 
-    protected final boolean subtypefinal;
+    protected final boolean subTypeFinal;
 
     protected volatile boolean inited = false;
 
@@ -49,7 +49,7 @@ public class ArrayEncoder<T> implements Encodeable<Writer, T[]> {
             factory.register(type, this);
             this.componentEncoder = factory.loadEncoder(this.componentType);
             this.anyEncoder = factory.getAnyEncoder();
-            this.subtypefinal = (this.componentType instanceof Class) && Modifier.isFinal(((Class) this.componentType).getModifiers());
+            this.subTypeFinal = (this.componentType instanceof Class) && Modifier.isFinal(((Class) this.componentType).getModifiers());
         } finally {
             inited = true;
             synchronized (lock) {
@@ -68,12 +68,14 @@ public class ArrayEncoder<T> implements Encodeable<Writer, T[]> {
             out.writeNull();
             return;
         }
-        if (value.length == 0) {
+        int iMax = value.length - 1;
+        if (iMax == -1) {
             out.writeArrayB(0, this, componentEncoder, value);
             out.writeArrayE();
             return;
         }
-        if (this.componentEncoder == null) {
+        Encodeable<Writer, Object> itemEncoder = this.componentEncoder;
+        if (itemEncoder == null) {
             if (!this.inited) {
                 synchronized (lock) {
                     try {
@@ -84,31 +86,29 @@ public class ArrayEncoder<T> implements Encodeable<Writer, T[]> {
                 }
             }
         }
-        Encodeable<Writer, Object> itemEncoder = this.componentEncoder;
-        if (subtypefinal) {
+        if (subTypeFinal) {
             if (out.writeArrayB(value.length, this, itemEncoder, value) < 0) {
-                boolean first = true;
-                for (Object v : value) {
-                    if (!first) out.writeArrayMark();
-                    writeMemberValue(out, member, itemEncoder, v, first);
-                    if (first) first = false;
+                for (int i = 0;; i++) {
+                    writeMemberValue(out, member, itemEncoder, value[i], i);
+                    if (i == iMax) break;
+                    out.writeArrayMark();
                 }
             }
         } else {
             if (out.writeArrayB(value.length, this, itemEncoder, value) < 0) {
                 final Type comp = this.componentType;
-                boolean first = true;
-                for (Object v : value) {
-                    if (!first) out.writeArrayMark();
-                    writeMemberValue(out, member, ((v != null && (v.getClass() == comp || out.specify() == comp)) ? itemEncoder : anyEncoder), v, first);
-                    if (first) first = false;
+                for (int i = 0;; i++) {
+                    Object v = value[i];
+                    writeMemberValue(out, member, ((v != null && (v.getClass() == comp || out.specify() == comp)) ? itemEncoder : anyEncoder), v, i);
+                    if (i == iMax) break;
+                    out.writeArrayMark();
                 }
             }
         }
         out.writeArrayE();
     }
 
-    protected void writeMemberValue(Writer out, EnMember member, Encodeable<Writer, Object> encoder, Object value, boolean first) {
+    protected void writeMemberValue(Writer out, EnMember member, Encodeable<Writer, Object> encoder, Object value, int index) {
         encoder.convertTo(out, value);
     }
 
@@ -122,6 +122,11 @@ public class ArrayEncoder<T> implements Encodeable<Writer, T[]> {
         return type;
     }
 
+    @Override
+    public boolean specifyable() {
+        return false;
+    }
+
     public Type getComponentType() {
         return componentType;
     }
@@ -129,5 +134,4 @@ public class ArrayEncoder<T> implements Encodeable<Writer, T[]> {
     public Encodeable<Writer, Object> getComponentEncoder() {
         return componentEncoder;
     }
-
 }