.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,29 +1,27 @@
-<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>
-</ol>
+</ol> 
 
 <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在接口定义上使用了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显得很简单，这体现了Redkale的简易性，而并非是不足，从一个良好的设计习惯或架构上来看，有些常用功能是不需要提供的，如Redkale的HTTP服务不支持JSP, JSP其实算是一个落后的技术，现在是一个多样化终端的时代，终端不只局限于桌面程序和PC浏览器，还有原生App、混合式App、微信端、移动H5、提供第三方接口等各种形式的终端，这些都不是JSP能方便兼顾的，而HTTP+JSON作为通用性接口可以避免重复开发，模版引擎的功能加上各种强大的JS框架足以取代JSP。Redkale在功能上做了筛选，不会为了迎合主流而提供，而是以良好的设计思想为指导。这是Redkale的主导思维。
 </p>
 
 
-&nbsp;&nbsp;&nbsp;由于RedKale使用了JDK 8 内置的ASM包，所以需要在源码工程中的编译器选项中加入： <b>-XDignore.symbol.file=true</b>
+&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' target='_blank'>https://redkale.org</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>基本文档:&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>欢迎加入Redkale QQ群:  527523235</b>
-
-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;<h5>欢迎加入Redkale QQ群:  527523235</h5>
 &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/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

@@ -0,0 +1,23 @@
+#!/bin/sh
+
+export LC_ALL="zh_CN.UTF-8"
+
+APP_HOME=`dirname "$0"`
+
+cd "$APP_HOME"/..
+
+APP_HOME=`pwd`
+
+if [ ! -f "$APP_HOME"/conf/application.xml ]; then 
+     APP_HOME="$APP_HOME"/..  
+fi
+
+lib="$APP_HOME"/lib
+for jar in `ls $APP_HOME/lib/*.jar`
+do
+    lib=$lib:$jar
+done
+export CLASSPATH=$CLASSPATH:$lib
+
+echo "$APP_HOME"
+java -DAPP_HOME="$APP_HOME"  org.redkale.boot.Application $@ &

bin/restart.cmd

@@ -4,5 +4,6 @@ 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
+call "%APP_HOME%\bin\shutdown.cmd" 
 
+call "%APP_HOME%\bin\start.cmd" 

bin/restart.sh

@@ -0,0 +1,20 @@
+#!/bin/sh
+
+export LC_ALL="zh_CN.UTF-8"
+
+APP_HOME=`dirname "$0"`
+
+cd "$APP_HOME"/..
+
+APP_HOME=`pwd`
+
+if [ ! -f "$APP_HOME"/conf/application.xml ]; then 
+     APP_HOME="$APP_HOME"/..  
+fi
+
+cd "$APP_HOME"
+
+"$APP_HOME"/bin/shutdown.sh
+
+"$APP_HOME"/bin/start.sh
+

bin/shutdown.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=SHUTDOWN -DAPP_HOME=%APP_HOME% -classpath %APP_HOME%\lib\* org.redkale.boot.Application

bin/shutdown.cmd

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

bin/start.cmd

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

bin/start.sh

@@ -24,5 +24,5 @@ done
 export CLASSPATH=$CLASSPATH:$lib
 
 echo "$APP_HOME"
-nohup  java -DAPP_HOME="$APP_HOME" org.redkale.boot.Application > "$APP_HOME"/log.out &
+nohup  java -server -DAPP_HOME="$APP_HOME" org.redkale.boot.Application > "$APP_HOME"/logs.out &
 

conf/application.xml

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

conf/config.properties

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

conf/logging.properties

@@ -1,9 +1,10 @@
 
 
 handlers = java.util.logging.ConsoleHandler
+# handlers = java.util.logging.FileHandler
 
 ############################################################
-.level = FINER
+.level = FINEST
 
 java.level = INFO
 javax.level = INFO
@@ -14,11 +15,11 @@ jdk.level = INFO
 
 java.util.logging.FileHandler.level = FINER
 #10M
-java.util.logging.FileHandler.limit = 10485760
+java.util.logging.FileHandler.limit = 10M
-java.util.logging.FileHandler.count = 10000
+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.pattern = ${APP_HOME}/logs-%tY%tm/log-%tY%tm%td.log
-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
 java.util.logging.FileHandler.append = true
 
-java.util.logging.ConsoleHandler.level = FINER
+java.util.logging.ConsoleHandler.level = FINEST

conf/persistence.xml

@@ -1,37 +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.driver" value="com.mysql.jdbc.Driver"/>
-            <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.driver" value="oracle.jdbc.driver.OracleDriver"/>
-            <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/user?autoReconnect=true&amp;characterEncoding=utf8"/>
-            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
-            <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

lib/readme.txt

@@ -1 +1 @@
-<EFBFBD><EFBFBD><EFBFBD>н<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>jarĬ<EFBFBD>Ϸ<EFBFBD><EFBFBD>ڴ˴<EFBFBD>
+<EFBFBD><EFBFBD><EFBFBD>н<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ĵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>jarĬ<EFBFBD>Ϸ<EFBFBD><EFBFBD>ڴ˴<EFBFBD> 

libs/readme.txt

@@ -1 +0,0 @@
-<EFBFBD>Լ<EFBFBD><EFBFBD><EFBFBD>ҵ<EFBFBD><EFBFBD>jarĬ<EFBFBD>Ϸ<EFBFBD><EFBFBD>ڴ˴<EFBFBD>

my/assembly.xml

@@ -16,10 +16,6 @@
             <directory>${project.basedir}/conf</directory>  
             <outputDirectory>conf</outputDirectory>  
         </fileSet>  
-        <fileSet>  
-            <directory>${project.basedir}/libs</directory>  
-            <outputDirectory>libs</outputDirectory>  
-        </fileSet>
         <fileSet>  
             <directory>${project.basedir}/logs</directory>  
             <outputDirectory>logs</outputDirectory>  

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

@@ -0,0 +1,173 @@
+<?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>http://redkale.org</url>
+    <description>redkale -- java framework</description>
+    <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>https://www.apache.org/licenses/</url>     
+            <distribution>repo</distribution>    
+            <comments>Apache License</comments>     
+        </license>      
+    </licenses>
+    
+    <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>  
+    
+    <distributionManagement>
+        <snapshotRepository>
+            <id>ossrh</id>
+            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+        </snapshotRepository>
+        <repository>
+            <id>ossrh</id>
+            <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>${maven-compiler-plugin.version}</version>                                
+                <configuration>
+					<compilerArgument>-parameters</compilerArgument>
+                    <encoding>UTF-8</encoding>
+                    <compilerArguments>
+                        <verbose />
+                    </compilerArguments>
+                </configuration>    
+            </plugin>
+           
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>${maven-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-gpg-plugin</artifactId>
+                <version>${maven-gpg-plugin.version}</version>
+                <executions>
+                    <execution>
+                        <id>sign-artifacts</id>
+                        <phase>verify</phase>
+                        <goals>
+                            <goal>sign</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-source-plugin</artifactId>
+                <version>${maven-plugin.version}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+                <version>${maven-plugin.version}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>  
+            
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-assembly-plugin</artifactId>   
+                <version>${maven-plugin.version}</version>
+                <configuration>
+                    <appendAssemblyId>false</appendAssemblyId>
+                    <descriptors>   
+                        <descriptor>assembly.xml</descriptor>  
+                    </descriptors> 
+                </configuration>
+                <executions>
+                    <execution>
+                        <id>redkale</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+                                
+        </plugins>
+    </build>
+    
+</project>

my/readme.txt

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

@@ -4,146 +4,138 @@
     <groupId>org.redkale</groupId>
     <artifactId>redkale</artifactId>
     <packaging>jar</packaging>
-    <url>http://redkale.org</url>
+    <name>RedkaleProject</name>     
+    <url>https://redkale.org</url>
     <description>redkale -- java framework</description>
-    <version>1.6.2</version>
+    <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>http://www.apache.org/licenses/</url>     
+            <url>https://www.apache.org/licenses/</url>     
             <distribution>repo</distribution>    
             <comments>Apache License</comments>     
-        </license>     
+        </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>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>     
             <timezone>8</timezone>     
         </developer>     
     </developers>  
-    
+
-    <properties>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-        <maven.compiler.source>1.8</maven.compiler.source>
-        <maven.compiler.target>1.8</maven.compiler.target>
-    </properties>
-    <name>Redkale</name>
-    <distributionManagement>
-        <snapshotRepository>
-            <id>ossrh</id>
-            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
-        </snapshotRepository>
-        <repository>
-            <id>ossrh</id>
-            <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.5.1</version>                                
+                <version>${maven-compiler-plugin.version}</version>                                               
-                <configuration>
+                <configuration>				
                     <encoding>UTF-8</encoding>
-                    <compilerArguments>
+                    <compilerArgs>
-                        <verbose />
+                        <arg>-parameters</arg>
-                        <bootclasspath>${java.home}/lib/rt.jar</bootclasspath>
+                    </compilerArgs>
-                    </compilerArguments>
+                </configuration>
-                </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>2.6</version>
+                <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-gpg-plugin</artifactId>
+                <artifactId>maven-surefire-plugin</artifactId>
-                <version>1.6</version>
+                <version>${maven-surefire-plugin.version}</version>
-                <executions>
-                    <execution>
-                        <id>sign-artifacts</id>
-                        <phase>verify</phase>
-                        <goals>
-                            <goal>sign</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-source-plugin</artifactId>
-                <version>3.0.0</version>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>jar</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-javadoc-plugin</artifactId>
-                <version>2.10.3</version>
-                <executions>
-                    <execution>
-                        <goals>
-                            <goal>jar</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>  
-            
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-assembly-plugin</artifactId>   
-                <version>3.0.0</version>
                 <configuration>
-                    <appendAssemblyId>false</appendAssemblyId>
+                    <forkMode>once</forkMode>
-                    <descriptors>   
+                    <argLine>-Dfile.encoding=UTF-8</argLine>
-                        <descriptor>assembly.xml</descriptor>  
-                    </descriptors> 
                 </configuration>
-                <executions>
-                    <execution>
-                        <id>redkale</id>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>single</goal>
-                        </goals>
-                    </execution>
-                </executions>
             </plugin>
-                                
+        
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-failsafe-plugin</artifactId>
+                <version>${maven-failsafe-plugin.version}</version>
+            </plugin>
         </plugins>
     </build>
     

root/readme.txt

@@ -0,0 +1 @@
+ 

src/META-INF/application-template.xml

@@ -1,283 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- 
-    文件说明:
-        ${APP_HOME} 指当前程序的根目录APP_HOME
-        没注明唯一的节点可多个存在
-        required： 被声明required的属性值不能为空
-        
-                                            group
-                                         /  /  \  \  
-                                      /    /    \   \   
-                                   /     /       \    \                      
-                               node1   node2   node3  node4
-                             /       \                             
-                          /             \
-                       /                   \
-                    /                         \
-             serviceid1                       serviceid2
-            /       \                        /           \
-  serviceid1_name1  serviceid1_name2   serviceid2_name1  serviceid2_name2    
--->
-<!--     
-    address:  本地局域网的IP地址， 默认值为默认网卡的ip，当不使用默认值需要指定值，如192.168.1.22
-    port: required  程序的管理Server的端口，用于关闭或者与监管系统进行数据交互
-    lib:  加上额外的lib路径,多个路径用分号;隔开； 默认为空。  例如: ${APP_HOME}/lib/a.jar;${APP_HOME}/lib2/b.jar;
--->
-<application port="6560" lib="">  
-    
-    <!-- 
-        【节点全局唯一】
-        所有服务所需的资源 
-    -->
-    <resources>  
-        
-        <!--
-            【节点全局唯一】
-            transport节点只能有一个，用于配置所有Transport的池参数，没配置该节点将自动创建一个。
-            threads： 线程总数， 默认: <group>节点数*CPU核数*8
-            bufferCapacity: ByteBuffer的初始化大小， 默认: 8K; 
-            bufferPoolSize： ByteBuffer池的大小，默认: <group>节点数*CPU核数*8
-            strategy: 远程请求的负载均衡策略， 必须是org.redkale.net.TransportStrategy的实现类
-        -->
-        <transport bufferCapacity="8K" bufferPoolSize="32" threads="32"/>
-        
-        <!--
-            一个组包含多个node， 同一Service服务可以由多个进程提供，这些进程称为一个GROUP，且同一GROUP内的进程必须在同一机房或局域网内
-            一个group节点对应一个 Transport 对象。
-            name: 服务组ID，长度不能超过11个字节. 默认为空字符串。 注意: name不能包含$符号。
-            protocol：值范围：UDP TCP， 默认TCP
-            subprotocol: 子协议，预留字段。默认值为空
-            注意: 一个node只能所属一个group。只要存在protocol=SNCP的Server节点信息， 就必须有group节点信息。
-        -->
-        <group name="" protocol="TCP">
-            <!--
-                需要将本地node的addr与port列在此处。
-                同一个<node>节点值只能存在一个<group>节点内，即同一个addr+port只能属于一个group。
-                addr: required IP地址
-                port: required 端口
-                clients: 连接池数， 默认: CPU核数*4
-                buffers: ByteBuffer对象池的大小， 默认: CPU核数*8
-            -->
-            <node addr="127.0.0.1" port="7070"/>
-        </group>
-        
-        <!--
-            全局的数据源设置, 可以是CacheSource、DataSource， JDBC的DataSource通常通过persistence.xml配置，此处多用于CacheSource的配置
-            name:  资源名，用于依赖注入。
-            value：类名，必须是CacheSource或DataSource的子类，且必须实现Service接口。
-            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的子类
-        -->
-        <listener value="org.redkalex.xxx.XXXApplicationListener"/>
-        
-        <!-- 
-            【节点全局唯一】
-            全局的参数配置, 可以通过@Resource(name="property.xxxxxx") 进行注入<property>的信息, 被注解的字段类型只能是String、primitive class
-            如果name是system.property.开头的值将会在进程启动时进行System.setProperty("yyyy", "YYYYYY")操作。
-            如果name是mimetype.property.开头的值将会在进程启动时进行MimeType.add("yyyy", "YYYYYY")操作。
-            load:  加载文件，多个用;隔开。
-            默认置入的system.property.的有：
-               System.setProperty("convert.json.tiny", "true");
-               System.setProperty("convert.bson.tiny", "true");
-               System.setProperty("convert.json.pool.size", "128");
-               System.setProperty("convert.bson.pool.size", "128");
-               System.setProperty("convert.json.writer.buffer.defsize", "4096");
-               System.setProperty("convert.bson.writer.buffer.defsize", "4096");
-               
-            <properties>节点下也可包含非<property>节点，其节点可以通过@Resource(name="properties.xxxxxx")进行注入, 被注解的字段类型只能是AnyValue、AnyValue[]
-        -->
-        <properties load="config.properties">
-            <property name="system.property.yyyy" value="YYYYYY"/>
-            <property name="xxxxxx" value="XXXXXXXX"/>
-            <property name="xxxxxx" value="XXXXXXXX"/>
-            <property name="xxxxxx" value="XXXXXXXX"/>
-        </properties>
-                
-    </resources> 
-    <!--
-        protocol: required  server所启动的协议，Redkale内置的有HTTP、SNCP、WATCH。协议均使用TCP实现; WATCH服务只能存在一个。
-        name: 服务的名称，用于监控识别，一个配置文件中的server.name不能重复,命名规则: 字母、数字、下划线
-        host:  服务所占address ， 默认: 0.0.0.0
-        port:  required 服务所占端口 
-        root:  如果是web类型服务，则包含页面  默认:{APP_HOME}/root
-        lib: server额外的class目录， 默认为${APP_HOME}/libs/*; 
-        excludelibs: 排除lib.path与excludes中的正则表达式匹配的路径, 多个正则表达式用分号;隔开
-        charset: 文本编码， 默认: UTF-8
-        backlog:  默认10K
-        threads： 线程总数， 默认: CPU核数*16
-        maxconns：最大连接数, 小于1表示无限制， 默认: 0
-        maxbody: request.body最大值， 默认: 64K
-        bufferCapacity: ByteBuffer的初始化大小， 默认: 8K;  如果是HTTP协议则默认: 16K + 16B (兼容HTTP 2.0、WebSocket)
-        bufferPoolSize： ByteBuffer池的大小，默认: CPU核数*512
-        responsePoolSize： Response池的大小，默认: CPU核数*256
-        readTimeoutSecond: 读操作超时秒数， 默认0， 表示永久不超时
-        writeTimeoutSecond:  写操作超时秒数， 默认0， 表示永久不超时
-        interceptor: 启动/关闭NodeServer时被调用的拦截器实现类，必须是org.redkale.boot.NodeInterceptor的子类，默认为null
-    -->
-    <server protocol="HTTP" host="127.0.0.1" port="6060" root="root" lib=""> 
-        
-        <!-- 
-           加载所有的Service服务;
-           在同一个进程中同一个name同一类型的Service将共用同一个实例
-           autoload="true"  默认值. 自动加载classpath下所有的Service类  
-           autoload="false" 需要显著的指定Service类
-           includes： 当autoload="true"， 拉取类名与includes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
-           excludes： 当autoload="true"， 排除类名与excludes中的正则表达式匹配的类, 多个正则表达式用分号;隔开           
-           groups:   所属组的节点,多个节点值用;隔开，如果配置文件中存在多个SNCP协议的Server节点，需要显式指定group属性.
-                    当 protocol == SNCP 时 group表示当前Server与哪些节点组关联。
-                    当 protocol != SNCP 时 group只能是空或者一个group的节点值，不能为多个节点值。
-        -->
-        <services autoload="true" includes="" excludes="">
-
-            <!-- 显著加载指定的Service的接口类 -->
-            <service value="com.xxx.XXX1Service"/>
-            <!-- 
-               name:   显式指定name，覆盖默认的空字符串值。 注意: name不能包含$符号。
-               groups: 显式指定groups，覆盖<services>节点的groups默认值。
-               ignore: 是否禁用， 默认为false。
-            -->
-            <service value="com.xxx.XXX2Service" name="" groups="xxx;yyy"/>
-            <!--   给Service增加配置属性 -->
-            <service value="com.xxx.XXX1Service"> 
-                <!-- property节点值在 public void init(AnyValue conf) 方法中可以通过 AnyValue properties =  conf.getAnyValue("properties");获取 -->
-                <property name="xxxxxx" value="XXXXXXXX"/>  
-                <property name="xxxxxx" value="XXXXXXXX"/>
-            </service>
-        </services>
-        
-        <!-- 
-           加载所有的Filter服务;
-           autoload="true"  默认值.  
-           autoload="false" 需要显著的指定Filter类
-           includes： 当autoload="true"， 拉取类名与includes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
-           excludes： 当autoload="true"， 排除类名与excludes中的正则表达式匹配的类, 多个正则表达式用分号;隔开    
-        -->
-        <filters autoload="true" includes="" excludes="">
-            
-            <!-- 
-               显著加载指定的Filter类
-               value=: Filter类名。必须与Server的协议层相同，HTTP必须是HttpFilter
-               ignore: 是否禁用， 默认为false。
-            -->
-            <!-- 显著加载指定的Filter类 -->
-            <filter value="com.xxx.XXX1Filter"/>
-            
-            <!--   给Filter增加配置属性 -->
-            <filter value="com.xxx.XXX12Filter"> 
-                <!-- property节点值在 public void init(AnyValue conf) 方法中可以通过 AnyValue properties =  conf.getAnyValue("properties");获取 -->
-                <property name="xxxxxx" value="XXXXXXXX"/>  
-                <property name="xxxxxx" value="XXXXXXXX"/>
-            </filter>
-        </filters>
-        
-        <!-- 
-           REST的核心配置项
-           当Server为HTTP协议时, rest节点才有效。存在[rest]节点则Server启动时会加载REST服务, 节点可以多个,(WATCH协议不需要设置，系统会自动生成)
-           path:     servlet的ContextPath前缀 默认为空
-           base:     REST服务的BaseServlet，必须是 org.redkale.net.http.HttpServlet 的子类，且子类必须标记@HttpUserType。
-           autoload：默认值"true"  默认值. 加载当前server所能使用的Servce对象;    
-           includes：当autoload="true"， 拉取类名与includes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
-           excludes：当autoload="true"， 排除类名与excludes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
-        -->
-        <rest path="/pipes" base="org.redkale.net.http.HttpServlet" autoload="true" includes="" excludes="">
-            <!-- 
-               value:  Service类名，列出的表示必须被加载的Service对象
-               ignore: 是否忽略，设置为true则不会加载该Service对象，默认值为false
-            -->
-            <service value="com.xxx.XXXXService"/>
-            <!-- 
-               value:  WebSocket类名，列出的表示必须被加载且标记为@RestWebSocket的WebSocket对象
-               ignore: 是否忽略，设置为true则不会加载该RestWebSocket对象，默认值为false
-            -->
-            <websocket value="com.xxx.XXXXRestWebSocket"/>
-        </rest>
-        
-        <!--
-           【节点在<server>中唯一】
-           当Server为HTTP协议时, request节点才有效。
-           remoteaddr 节点: 替换请求方节点的IP地址， 通常请求方是由nginx等web静态服务器转发过的则需要配置该节点。
-           且value值只能是以request.headers.开头，表示从request.headers中获取对应的header值。
-           例如下面例子获取request.getRemoteAddr()值，如果header存在X-RemoteAddress值则返回X-RemoteAddress值，不存在返回getRemoteAddress()。
-        -->
-        <request>
-            <remoteaddr value="request.headers.X-RemoteAddress"/>
-        </request>
-        
-        <!--
-           【节点在<server>中唯一】
-           当Server为HTTP协议时, response节点才有效。
-           defcookie 节点: 当response里输出的cookie没有指定domain 和path时，使用该节点的默认值。
-           如果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状态码
-        -->
-        <response>
-            <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"/>
-            <setheader name="Access-Control-Allow-Credentials" value="true"/>
-            <options auto="true" />
-        </response>
-            
-        <!-- 
-           【节点在<server>中唯一】
-           当Server为HTTP协议时，ResourceServlet才有效. 默认存在一个有默认属性的resource-servlet节点
-           webroot: web资源的根目录, 默认取server节点中的root值
-           servlet: 静态资源HttpServlet的实现，默认使用HttpResourceServlet
-           index : 启始页，默认值：index.html
-        -->
-        <resource-servlet webroot="root" index="index.html">
-            <!--
-                【节点在<resource-servlet>中唯一】
-                资源缓存的配置, 默认存在一个含默认属性的caches节点
-                limit:  资源缓存最大容量， 默认: 0, 为0表示不缓存， 单位可以是B、K、M、G，不区分大小写
-                lengthmax: 可缓存的文件大小上限， 默认: 1M（超过1M的文件不会被缓存）
-                watch: 是否监控缓存文件的变化， 默认为false，不监控
-            -->
-            <cache  limit="0M" lengthmax="1M" watch="false"/>
-            <!--
-               支持类似nginx中的rewrite， 目前只支持静态资源对静态资源的跳转。
-               type: 匹配的类型, 目前只支持location(匹配requestURI), 默认: location
-               match: 匹配的正则表达式
-               forward: 需跳转后的资源链接
-               例如下面例子是将/xxx-yyy.html的页面全部跳转到/xxx.html
-            -->
-            <rewrite type="location" match="^/([^-]+)-[^-\.]+\.html(.*)" forward="/$1.html"/>
-        </resource-servlet>
-        <!-- 
-           加载所有的Servlet服务;
-           path:  servlet的ContextPath前缀 默认为空
-           autoload="true"  默认值. 自动加载classpath下所有的Servlet类 
-           autoload="false" 需要显著的指定Service类
-           includes： 当autoload="true"， 拉取类名与includes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
-           excludes： 当autoload="true"， 排除类名与excludes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
-        -->
-        <servlets path="/pipes" autoload="true" includes="" excludes="">
-            <!-- 
-               显著加载指定的Servlet类
-               value=: Servlet类名。必须与Server的协议层相同，HTTP必须是HttpServlet
-               ignore: 是否禁用， 默认为false。
-            -->
-            <servlet value="com.xxx.XXX1Servlet" />
-            <servlet value="com.xxx.XXX2Servlet" />
-            <servlet value="com.xxx.XXX3Servlet" >
-                <property name="xxxxxx" value="XXXXXXXX"/>
-                <property name="yyyyyy" value="YYYYYYYY"/>
-            </servlet>
-        </servlets>
-    </server>
-    
-    <server protocol="SNCP" host="127.0.0.1" port="7070" root="root" lib=""> 
-        <!-- 参数完全同上 -->
-        <services autoload="true" includes="" excludes="" />
-    </server>
-</application>

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/javax/persistence/GeneratedValue.java

@@ -1,63 +0,0 @@
-/** *****************************************************************************
- * Copyright (c) 2008 - 2013 Oracle Corporation. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
- * which accompanies this distribution.
- * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
- * and the Eclipse Distribution License is available at
- * http://www.eclipse.org/org/documents/edl-v10.php.
- *
- * Contributors:
- *     Linda DeMichiel - Java Persistence 2.1
- *     Linda DeMichiel - Java Persistence 2.0
- *
- ***************************************************************************** */
-package javax.persistence;
-
-import java.lang.annotation.Target;
-import java.lang.annotation.Retention;
-import static java.lang.annotation.ElementType.FIELD;
-import static java.lang.annotation.ElementType.METHOD;
-import static java.lang.annotation.RetentionPolicy.RUNTIME;
-
-/**
- * Provides for the specification of generation strategies for the
- * values of primary keys.
- *
- * <p>
- * The <code>GeneratedValue</code> annotation
- * may be applied to a primary key property or field of an entity or
- * mapped superclass in conjunction with the {@link Id} annotation.
- * The use of the <code>GeneratedValue</code> annotation is only
- * required to be supported for simple primary keys. Use of the
- * <code>GeneratedValue</code> annotation is not supported for derived
- * primary keys.
- *
- * <pre>
- *
- *     Example 1:
- *
- *     &#064;Id
- *     &#064;GeneratedValue(strategy=SEQUENCE, generator="CUST_SEQ")
- *     &#064;Column(name="CUST_ID")
- *     public Long getId() { return id; }
- *
- *     Example 2:
- *
- *     &#064;Id
- *     &#064;GeneratedValue(strategy=TABLE, generator="CUST_GEN")
- *     &#064;Column(name="CUST_ID")
- *     Long id;
- * </pre>
- *
- * @see Id
- *
- * @since Java Persistence 1.0
- */
-@Target({METHOD, FIELD})
-@Retention(RUNTIME)
-
-public @interface GeneratedValue {
-
-}

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

@@ -41,7 +41,7 @@
                             html.push(' <tr>');
                             html.push('<td style="color:#ff00ff;">' + action.url + '</td>');
                             html.push('<td>' + action.comment + '</td>');
-                            html.push('<td class="s">模块ID: ' + servlet.moduleid + '<br/>操作ID: ' + action.actionid + '<br/>需鉴权: ' + (action.auth ? '<font style="font-weight:bold;color:green;">true</font>' : '<font color=red>false</font>') + '</td>');
+                            html.push('<td class="s" style="width:80px;">模块ID: ' + servlet.moduleid + '<br/>操作ID: ' + action.actionid + '<br/>需鉴权: ' + (action.auth ? '<font style="font-weight:bold;color:green;">true</font>' : '<font color=red>false</font>') + '</td>');
                             var paramshtml = [];
                             paramshtml.push('<table class="subtable">');
                             for (var p = 0; p < action.params.length; p++) {
@@ -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.style == "HEADER") c = ' style="color:red;' + w + '"';
-                                    if (param.src == "COOKIE") c = ' style="color:blue;' + 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

@@ -0,0 +1,368 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+    文件说明:
+        ${APP_HOME} 指当前程序的根目录APP_HOME
+        没注明唯一的节点可多个存在
+        required： 被声明required的属性值不能为空
+        
+                                            group
+                                         /  /  \  \  
+                                      /    /    \   \   
+                                   /     /       \    \                      
+                               node1   node2   node3  node4
+                             /       \                             
+                          /             \
+                       /                   \
+                    /                         \
+             serviceid1                       serviceid2
+            /       \                        /           \
+  serviceid1_name1  serviceid1_name2   serviceid2_name1  serviceid2_name2    
+-->
+<!--     
+    nodeid: int     进程的节点ID，用于分布式环境，一个系统中节点ID必须全局唯一，使用cluster时框架会进行唯一性校验
+    name:           进程的名称，用于监控识别，命名规则: 字母、数字、下划线、短横、点
+    address:        本地局域网的IP地址， 默认值为默认网卡的ip，当不使用默认值需要指定值，如192.168.1.22
+    port: required  程序的管理Server的端口，用于关闭或者与监管系统进行数据交互
+    lib:            加上额外的lib路径,多个路径用分号;隔开； 默认为空。  例如: ${APP_HOME}/lib/a.jar;${APP_HOME}/lib2/b.jar;
+-->
+<application nodeid="1000" port="6560" lib="">  
+    
+    <!-- 
+        【节点全局唯一】
+        所有服务所需的资源 
+    -->
+    <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的池参数，没配置该节点将自动创建一个。
+            threads：            线程总数， 默认: <group>节点数*CPU核数*2
+            bufferCapacity:      ByteBuffer的初始化大小， 默认: 32K; 
+            bufferPoolSize：     ByteBuffer池的大小，默认: 线程总数*4
+            readTimeoutSeconds:  TCP读取超时秒数, 默认为6秒， 为0表示无超时限制
+            writeTimeoutSeconds: TCP写入超时秒数, 默认为6秒， 为0表示无超时限制
+            strategy:            远程请求的负载均衡策略， 必须是org.redkale.net.TransportStrategy的实现类
+        -->
+        <transport bufferCapacity="32K" bufferPoolSize="32" threads="32" readTimeoutSeconds="6" writeTimeoutSeconds="6"/>
+        
+        <!--
+           【节点全局唯一】
+            自动扫描时排除部分包路径
+            value：    排除lib.path与excludes中的正则表达式匹配的路径, 多个正则表达式用分号;隔开
+        -->
+        <excludelibs value="^.*mysql.*$;^.*kafka.*$"/>
+        
+        <!--
+           【节点全局唯一】
+            第三方服务发现管理接口
+            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不能重复,命名规则: 字母、数字、下划线
+            type： 实现类名，必须是org.redkale.mq.MessageAgent的子类
+            coder: MessageRecord的解析器类，必须是org.redkale.mq.MessageCoder<MessageRecord>的实现类, 
+                   可对数据包进行加密解密，默认值：org.redkale.mq.MessageRecordCoder
+            MQ节点下的子节点配置没有固定格式, 根据MessageAgent实现方的定义来配置
+        -->
+        <mq name="" type="org.redkalex.mq.kafka.KafkaMessageAgent">
+            <servers value="127.0.0.1:9101"/>
+            <consumer>
+                <property name="xxxxxx" value="XXXXXXXX"/>
+            </consumer>
+            <producer>
+                <property name="xxxxxx" value="XXXXXXXX"/>
+            </producer>
+        </mq>
+        
+        <!--
+            一个组包含多个node， 同一Service服务可以由多个进程提供，这些进程称为一个GROUP，且同一GROUP内的进程必须在同一机房或局域网内
+            一个group节点对应一个 Transport 对象。
+            name:         服务组ID，长度不能超过11个字节. 默认为空字符串。 注意: name不能包含$符号。
+            protocol：    值范围：UDP TCP， 默认TCP
+            注意: 一个node只能所属一个group。只要存在protocol=SNCP的Server节点信息， 就必须有group节点信息。
+        -->
+        <group name="" protocol="TCP">
+            <!--
+                需要将本地node的addr与port列在此处。
+                同一个<node>节点值只能存在一个<group>节点内，即同一个addr+port只能属于一个group。
+                addr: required IP地址
+                port: required 端口
+            -->
+            <node addr="127.0.0.1" port="7070"/>
+        </group>
+
+        <!--
+           Application启动的监听事件,可配置多个节点
+           value: 类名，必须是ApplicationListener的子类
+        -->
+        <listener value="org.redkalex.xxx.XXXApplicationListener"/>
+        
+        <!-- 
+            【节点全局唯一】
+            全局的参数配置, 可以通过@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("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" agent="">
+            <property name="system.property.yyyy" value="YYYYYY"/>
+            <property name="xxxxxx" value="XXXXXXXX"/>
+            <property name="xxxxxx" value="XXXXXXXX"/>
+            <property name="xxxxxx" value="XXXXXXXX"/>
+        </properties>
+                
+    </resources> 
+    <!--
+        protocol: required   server所启动的协议，Redkale内置的有HTTP、SNCP、WATCH。协议均使用TCP实现; WATCH服务只能存在一个。
+        name:                服务的名称，用于监控识别，一个配置文件中的server.name不能重复,命名规则: 字母、数字、下划线
+        host:                服务所占address ， 默认: 0.0.0.0
+        port:                required 服务所占端口 
+        root:                如果是web类型服务，则包含页面  默认:{APP_HOME}/root
+        lib:                 server额外的class目录， 默认为${APP_HOME}/libs/*; 
+        excludelibs:         排除lib.path与excludes中的正则表达式匹配的路径, 多个正则表达式用分号;隔开
+        charset:             文本编码， 默认: UTF-8
+        backlog:             默认10K
+        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池的大小，默认: 1024
+        aliveTimeoutSeconds: KeepAlive读操作超时秒数， 默认30， 0表示永久不超时; -1表示禁止KeepAlive
+        readTimeoutSeconds:  读操作超时秒数， 默认0， 表示永久不超时
+        writeTimeoutSeconds: 写操作超时秒数， 默认0， 表示永久不超时
+        interceptor:         启动/关闭NodeServer时被调用的拦截器实现类，必须是org.redkale.boot.NodeInterceptor的子类，默认为null
+    -->
+    <server protocol="HTTP" host="127.0.0.1" port="6060" root="root" lib=""> 
+        
+        <!-- 
+           【节点在<server>中唯一】
+           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 builder=""/>
+        
+        <!-- 
+           加载所有的Service服务;
+           在同一个进程中同一个name同一类型的Service将共用同一个实例
+           autoload="true"  默认值. 自动加载classpath下所有的Service类  
+           autoload="false" 需要显著的指定Service类
+           mq:        所属的MQ管理器，当 protocol == SNCP 时该值才有效, 存在该属性表示Service的SNCP协议采用消息总线代理模式
+           includes： 当autoload="true"， 拉取类名与includes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
+           excludes： 当autoload="true"， 排除类名与excludes中的正则表达式匹配的类, 多个正则表达式用分号;隔开           
+           groups:    所属组的节点,多个节点值用;隔开，如果配置文件中存在多个SNCP协议的Server节点，需要显式指定group属性.
+                         当 protocol == SNCP 时 group表示当前Server与哪些节点组关联。
+                         当 protocol != SNCP 时 group只能是空或者一个group的节点值，不能为多个节点值。
+                         特殊值"$cluster", 视为通过第三方服务注册发现管理工具来获取远程模式的ip端口信息
+        -->
+        <services autoload="true" includes="" excludes="">
+
+            <!-- 显著加载指定的Service的接口类 -->
+            <service value="com.xxx.XXX1Service"/>
+            <!-- 
+               name:   显式指定name，覆盖默认的空字符串值。 注意: name不能包含$符号。
+               mq:     所属的MQ管理器，当 protocol == SNCP 时该值才有效, 存在该属性表示Service的SNCP协议采用消息总线代理模式
+               groups: 显式指定groups，覆盖<services>节点的groups默认值。
+               ignore: 是否禁用， 默认为false。
+            -->
+            <service value="com.xxx.XXX2Service" name="" groups="xxx;yyy"/>
+            <!--   给Service增加配置属性 -->
+            <service value="com.xxx.XXX1Service"> 
+                <!-- property值在public void init(AnyValue conf)方法中可以通过AnyValue properties=conf.getAnyValue("properties")获取 -->
+                <property name="xxxxxx" value="XXXXXXXX"/>  
+                <property name="xxxxxx" value="XXXXXXXX"/>
+            </service>
+        </services>
+        
+        <!-- 
+           加载所有的Filter服务;
+           autoload="true"  默认值.  
+           autoload="false" 需要显著的指定Filter类
+           includes：       当autoload="true"， 拉取类名与includes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
+           excludes：       当autoload="true"， 排除类名与excludes中的正则表达式匹配的类, 多个正则表达式用分号;隔开    
+        -->
+        <filters autoload="true" includes="" excludes="">
+            
+            <!-- 
+               显著加载指定的Filter类
+               value=: Filter类名。必须与Server的协议层相同，HTTP必须是HttpFilter
+               ignore: 是否禁用， 默认为false。
+            -->
+            <!-- 显著加载指定的Filter类 -->
+            <filter value="com.xxx.XXX1Filter"/>
+            
+            <!--   给Filter增加配置属性 -->
+            <filter value="com.xxx.XXX12Filter"> 
+                <!-- property值在public void init(AnyValue conf)方法中可以通过AnyValue properties=conf.getAnyValue("properties")获取 -->
+                <property name="xxxxxx" value="XXXXXXXX"/>  
+                <property name="xxxxxx" value="XXXXXXXX"/>
+            </filter>
+        </filters>
+        
+        <!-- 
+           REST的核心配置项
+           当Server为HTTP协议时, rest节点才有效。存在[rest]节点则Server启动时会加载REST服务, 节点可以多个,(WATCH协议不需要设置，系统会自动生成)
+           path:     servlet的ContextPath前缀 默认为空 【注: 开启MQ时,该字段失效】
+           base:     REST服务的BaseServlet，必须是 org.redkale.net.http.HttpServlet 的子类，且子类必须标记@HttpUserType。
+           mq:        所属的MQ管理器, 存在该属性表示RestService的请求来自于消息总线 【注: 开启MQ时,path字段失效】
+           autoload：默认值"true"  默认值. 加载当前server所能使用的Servce对象;    
+           includes：当autoload="true"， 拉取类名与includes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
+           excludes：当autoload="true"， 排除类名与excludes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
+        -->
+        <rest path="/pipes" base="org.redkale.net.http.HttpServlet" autoload="true" includes="" excludes="">
+            <!-- 
+               value:  Service类名，列出的表示必须被加载的Service对象
+               ignore: 是否忽略，设置为true则不会加载该Service对象，默认值为false
+            -->
+            <service value="com.xxx.XXXXService"/>
+            <!-- 
+               value:  WebSocket类名，列出的表示必须被加载且标记为@RestWebSocket的WebSocket对象
+               ignore: 是否忽略，设置为true则不会加载该RestWebSocket对象，默认值为false
+            -->
+            <websocket value="com.xxx.XXXXRestWebSocket"/>
+        </rest>
+        
+        <!--
+           【节点在<server>中唯一】
+           当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>
+        
+        <!--
+           【节点在<server>中唯一】
+           当Server为HTTP协议时, response节点才有效。
+           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值
+           例如下面例子是在Response输出header时添加两个header（一个addHeader， 一个setHeader）。
+           options 节点: 设置了该节点且auto=true，当request的method=OPTIONS自动设置addheader、setheader并返回200状态码
+           date 节点: 设置了该节点且period有值(单位：毫秒);返回response会包含Date头信息，默认为period=0
+                      period=0表示实时获取当前时间;
+                      period<0表示不设置date;
+                      period>0表示定时获取时间; 设置1000表示每秒刷新Date时间
+        -->
+        <response>
+            <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"/>
+            <setheader name="Access-Control-Allow-Credentials" value="true"/>
+            <options auto="true" />
+            <date period="0" />
+        </response>
+        <!-- 
+           【节点在<server>中唯一】
+           当Server为HTTP协议时，render才有效. 指定输出引擎的实现类
+           value: 输出引擎的实现类, 必须是org.redkale.net.http.HttpRender的子类
+           suffixs: 引擎文件名后缀，多个用;隔开，默认值为: .htel
+        -->
+        <render value="org.redkalex.htel.HttpTemplateRender" suffixs=".htel"/>
+        <!-- 
+           【节点在<server>中唯一】
+           当Server为HTTP协议时，ResourceServlet才有效. 默认存在一个有默认属性的resource-servlet节点
+           webroot: web资源的根目录, 默认取server节点中的root值
+           servlet: 静态资源HttpServlet的实现，默认使用HttpResourceServlet
+           index :  启始页，默认值：index.html
+        -->
+        <resource-servlet webroot="root" index="index.html">
+            <!--
+                【节点在<resource-servlet>中唯一】
+                资源缓存的配置, 默认存在一个含默认属性的caches节点
+                limit:     资源缓存最大容量， 默认: 0, 为0表示不缓存， 单位可以是B、K、M、G，不区分大小写
+                lengthmax: 可缓存的文件大小上限， 默认: 1M（超过1M的文件不会被缓存）
+                watch:     是否监控缓存文件的变化， 默认为false，不监控
+            -->
+            <cache  limit="0M" lengthmax="1M" watch="false"/>
+            <!--
+               支持类似nginx中的rewrite， 目前只支持静态资源对静态资源的跳转。
+               type:    匹配的类型, 目前只支持location(匹配requestURI), 默认: location
+               match:   匹配的正则表达式
+               forward: 需跳转后的资源链接
+               例如下面例子是将/xxx-yyy.html的页面全部跳转到/xxx.html
+            -->
+            <rewrite type="location" match="^/([^-]+)-[^-\.]+\.html(.*)" forward="/$1.html"/>
+        </resource-servlet>
+        <!-- 
+           加载所有的Servlet服务;
+           path:            servlet的ContextPath前缀 默认为空
+           autoload="true"  默认值. 自动加载classpath下所有的Servlet类 
+           autoload="false" 需要显著的指定Service类
+           includes：       当autoload="true"， 拉取类名与includes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
+           excludes：       当autoload="true"， 排除类名与excludes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
+        -->
+        <servlets path="/pipes" autoload="true" includes="" excludes="">
+            <!-- 
+               显著加载指定的Servlet类
+               value=: Servlet类名。必须与Server的协议层相同，HTTP必须是HttpServlet
+               ignore: 是否禁用， 默认为false。
+            -->
+            <servlet value="com.xxx.XXX1Servlet" />
+            <servlet value="com.xxx.XXX2Servlet" />
+            <servlet value="com.xxx.XXX3Servlet" >
+                <property name="xxxxxx" value="XXXXXXXX"/>
+                <property name="yyyyyy" value="YYYYYYYY"/>
+            </servlet>
+        </servlets>
+    </server>
+    
+    <server protocol="SNCP" host="127.0.0.1" port="7070" root="root" lib=""> 
+        <!-- 参数完全同上 -->
+        <services autoload="true" includes="" excludes="" />
+    </server>
+</application>

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

@@ -11,13 +11,20 @@ javax.level = INFO
 com.sun.level = INFO
 
 #java.util.logging.FileHandler.level = FINE
-#10M
+
-java.util.logging.FileHandler.limit = 10485760
+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">
@@ -9,28 +12,21 @@
             -->
             <property name="javax.persistence.datasource" value="org.redkale.source.DataJdbcSource"/>
             <!-- 
-                是否开启缓存(标记为@Cacheable的Entity类)，值目前只支持两种： ALL: 所有开启缓存。 NONE: 关闭所有缓存
+                是否开启缓存(标记为@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的子类。 
+                是否自动建表当表不存在的时候， 目前只支持mysql、postgres， 默认为false
-                为了兼容用户习惯，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
-                             oracle.jdbc.driver.OracleDriver  ——————  oracle.jdbc.pool.OracleConnectionPoolDataSource
-                com.microsoft.sqlserver.jdbc.SQLServerDriver  ——————  com.microsoft.sqlserver.jdbc.SQLServerConnectionPoolDataSource
-                因此 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.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  -->
+            <!-- 最大连接数，默认值：CPU数 -->
-            <property name="javax.persistence.connections.limit" value="32"/>
+            <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"/>
@@ -38,16 +34,15 @@
             
             <!--  复制表结构的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.driver" value="com.mysql.jdbc.Driver"/>
             <property name="javax.persistence.jdbc.user" value="root"/>
             <property name="javax.persistence.jdbc.password" value="123456"/>
         </properties>

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

@@ -23,11 +23,17 @@ import java.lang.annotation.Target;
 
 /**
  * 值越大，优先级越高
- * 
+ *
  * @since Common Annotations 1.2
  */
 @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/Cacheable.java

@@ -51,4 +51,12 @@ public @interface Cacheable {
      * @return int
      */
     int interval() default 0;
+
+    /**
+     * DataSource是否直接返回对象的真实引用， 而不是copy一份
+     *
+     * @return boolean
+     */
+    boolean direct() default false;
+
 }

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.*;
-import java.lang.annotation.Retention;
-import java.lang.annotation.Documented;
 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/Id.java

@@ -45,7 +45,7 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
  * </pre>
  *
  * @see Column
- * @see GeneratedValue
+ * see GeneratedValue
  *
  * @since Java Persistence 1.0
  */

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

@@ -0,0 +1,44 @@
+/**
+ * <p>
+ * see: https://redkale.org
+ *
+ * @author zhangjx
+ *
+ */
+module redkale {
+
+    requires java.base;
+    requires java.logging;    
+    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;
+    exports org.redkale.source;
+    exports org.redkale.util;
+    exports org.redkale.watch;
+    
+    uses org.redkale.mq.MessageAgent;
+    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

@@ -0,0 +1,195 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+/**
+ * A visitor to visit a Java annotation. The methods of this class must be
+ * called in the following order: ( <tt>visit</tt> | <tt>visitEnum</tt> |
+ * <tt>visitAnnotation</tt> | <tt>visitArray</tt> )* <tt>visitEnd</tt>.
+ *
+ * @author Eric Bruneton
+ * @author Eugene Kuleshov
+ */
+public abstract class AnnotationVisitor {
+
+    /**
+     * The ASM API version implemented by this visitor. The value of this field
+     * must be one of {@link Opcodes#ASM4}, {@link Opcodes#ASM5} or {@link Opcodes#ASM6}.
+     */
+    protected final int api;
+
+    /**
+     * The annotation visitor to which this visitor must delegate method calls.
+     * May be null.
+     */
+    protected AnnotationVisitor av;
+
+    /**
+     * Constructs a new {@link AnnotationVisitor}.
+     *
+     * @param api
+     *            the ASM API version implemented by this visitor. Must be one
+     *            of {@link Opcodes#ASM4}, {@link Opcodes#ASM5} or {@link Opcodes#ASM6}.
+     */
+    public AnnotationVisitor(final int api) {
+        this(api, null);
+    }
+
+    /**
+     * Constructs a new {@link AnnotationVisitor}.
+     *
+     * @param api
+     *            the ASM API version implemented by this visitor. Must be one
+     *            of {@link Opcodes#ASM4}, {@link Opcodes#ASM5} or {@link Opcodes#ASM6}.
+     * @param av
+     *            the annotation visitor to which this visitor must delegate
+     *            method calls. May be null.
+     */
+    public AnnotationVisitor(final int api, final AnnotationVisitor av) {
+        this.api = api;
+        this.av = av;
+    }
+
+    /**
+     * Visits a primitive value of the annotation.
+     *
+     * @param name
+     *            the value name.
+     * @param value
+     *            the actual value, whose type must be {@link Byte},
+     *            {@link Boolean}, {@link Character}, {@link Short},
+     *            {@link Integer} , {@link Long}, {@link Float}, {@link Double},
+     *            {@link String} or {@link Type} of OBJECT or ARRAY sort. This
+     *            value can also be an array of byte, boolean, short, char, int,
+     *            long, float or double values (this is equivalent to using
+     *            {@link #visitArray visitArray} and visiting each array element
+     *            in turn, but is more convenient).
+     */
+    public void visit(String name, Object value) {
+        if (av != null) {
+            av.visit(name, value);
+        }
+    }
+
+    /**
+     * Visits an enumeration value of the annotation.
+     *
+     * @param name
+     *            the value name.
+     * @param desc
+     *            the class descriptor of the enumeration class.
+     * @param value
+     *            the actual enumeration value.
+     */
+    public void visitEnum(String name, String desc, String value) {
+        if (av != null) {
+            av.visitEnum(name, desc, value);
+        }
+    }
+
+    /**
+     * Visits a nested annotation value of the annotation.
+     *
+     * @param name
+     *            the value name.
+     * @param desc
+     *            the class descriptor of the nested annotation class.
+     * @return a visitor to visit the actual nested annotation value, or
+     *         <tt>null</tt> if this visitor is not interested in visiting this
+     *         nested annotation. <i>The nested annotation value must be fully
+     *         visited before calling other methods on this annotation
+     *         visitor</i>.
+     */
+    public AnnotationVisitor visitAnnotation(String name, String desc) {
+        if (av != null) {
+            return av.visitAnnotation(name, desc);
+        }
+        return null;
+    }
+
+    /**
+     * Visits an array value of the annotation. Note that arrays of primitive
+     * types (such as byte, boolean, short, char, int, long, float or double)
+     * can be passed as value to {@link #visit visit}. This is what
+     * {@link ClassReader} does.
+     *
+     * @param name
+     *            the value name.
+     * @return a visitor to visit the actual array value elements, or
+     *         &#60;tt&#62;null&#60;/tt&#62; if this visitor is not interested in visiting these
+     *         values. The 'name' parameters passed to the methods of this
+     *         visitor are ignored. <i>All the array values must be visited
+     *         before calling other methods on this annotation visitor</i>.
+     */
+    public AnnotationVisitor visitArray(String name) {
+        if (av != null) {
+            return av.visitArray(name);
+        }
+        return null;
+    }
+
+    /**
+     * Visits the end of the annotation.
+     */
+    public void visitEnd() {
+        if (av != null) {
+            av.visitEnd();
+        }
+    }
+}

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

@@ -0,0 +1,400 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+/**
+ * An {@link AnnotationVisitor} that generates annotations in bytecode form.
+ *
+ * @author Eric Bruneton
+ * @author Eugene Kuleshov
+ */
+final class AnnotationWriter extends AnnotationVisitor {
+
+    /**
+     * The class writer to which this annotation must be added.
+     */
+    private final ClassWriter cw;
+
+    /**
+     * The number of values in this annotation.
+     */
+    private int size;
+
+    /**
+     * <tt>true<tt> if values are named, <tt>false</tt> otherwise. Annotation
+     * writers used for annotation default and annotation arrays use unnamed
+     * values.
+     */
+    private final boolean named;
+
+    /**
+     * The annotation values in bytecode form. This byte vector only contains
+     * the values themselves, i.e. the number of values must be stored as a
+     * unsigned short just before these bytes.
+     */
+    private final ByteVector bv;
+
+    /**
+     * The byte vector to be used to store the number of values of this
+     * annotation. See {@link #bv}.
+     */
+    private final ByteVector parent;
+
+    /**
+     * Where the number of values of this annotation must be stored in
+     * {@link #parent}.
+     */
+    private final int offset;
+
+    /**
+     * Next annotation writer. This field is used to store annotation lists.
+     */
+    AnnotationWriter next;
+
+    /**
+     * Previous annotation writer. This field is used to store annotation lists.
+     */
+    AnnotationWriter prev;
+
+    // ------------------------------------------------------------------------
+    // Constructor
+    // ------------------------------------------------------------------------
+
+    /**
+     * Constructs a new {@link AnnotationWriter}.
+     *
+     * @param cw
+     *            the class writer to which this annotation must be added.
+     * @param named
+     *            <tt>true<tt> if values are named, <tt>false</tt> otherwise.
+     * @param bv
+     *            where the annotation values must be stored.
+     * @param parent
+     *            where the number of annotation values must be stored.
+     * @param offset
+     *            where in <tt>parent</tt> the number of annotation values must
+     *            be stored.
+     */
+    AnnotationWriter(final ClassWriter cw, final boolean named,
+            final ByteVector bv, final ByteVector parent, final int offset) {
+        super(Opcodes.ASM6);
+        this.cw = cw;
+        this.named = named;
+        this.bv = bv;
+        this.parent = parent;
+        this.offset = offset;
+    }
+
+    // ------------------------------------------------------------------------
+    // Implementation of the AnnotationVisitor abstract class
+    // ------------------------------------------------------------------------
+
+    @Override
+    public void visit(final String name, final Object value) {
+        ++size;
+        if (named) {
+            bv.putShort(cw.newUTF8(name));
+        }
+        if (value instanceof String) {
+            bv.put12('s', cw.newUTF8((String) value));
+        } else if (value instanceof Byte) {
+            bv.put12('B', cw.newInteger(((Byte) value).byteValue()).index);
+        } else if (value instanceof Boolean) {
+            int v = ((Boolean) value).booleanValue() ? 1 : 0;
+            bv.put12('Z', cw.newInteger(v).index);
+        } else if (value instanceof Character) {
+            bv.put12('C', cw.newInteger(((Character) value).charValue()).index);
+        } else if (value instanceof Short) {
+            bv.put12('S', cw.newInteger(((Short) value).shortValue()).index);
+        } else if (value instanceof Type) {
+            bv.put12('c', cw.newUTF8(((Type) value).getDescriptor()));
+        } else if (value instanceof byte[]) {
+            byte[] v = (byte[]) value;
+            bv.put12('[', v.length);
+            for (int i = 0; i < v.length; i++) {
+                bv.put12('B', cw.newInteger(v[i]).index);
+            }
+        } else if (value instanceof boolean[]) {
+            boolean[] v = (boolean[]) value;
+            bv.put12('[', v.length);
+            for (int i = 0; i < v.length; i++) {
+                bv.put12('Z', cw.newInteger(v[i] ? 1 : 0).index);
+            }
+        } else if (value instanceof short[]) {
+            short[] v = (short[]) value;
+            bv.put12('[', v.length);
+            for (int i = 0; i < v.length; i++) {
+                bv.put12('S', cw.newInteger(v[i]).index);
+            }
+        } else if (value instanceof char[]) {
+            char[] v = (char[]) value;
+            bv.put12('[', v.length);
+            for (int i = 0; i < v.length; i++) {
+                bv.put12('C', cw.newInteger(v[i]).index);
+            }
+        } else if (value instanceof int[]) {
+            int[] v = (int[]) value;
+            bv.put12('[', v.length);
+            for (int i = 0; i < v.length; i++) {
+                bv.put12('I', cw.newInteger(v[i]).index);
+            }
+        } else if (value instanceof long[]) {
+            long[] v = (long[]) value;
+            bv.put12('[', v.length);
+            for (int i = 0; i < v.length; i++) {
+                bv.put12('J', cw.newLong(v[i]).index);
+            }
+        } else if (value instanceof float[]) {
+            float[] v = (float[]) value;
+            bv.put12('[', v.length);
+            for (int i = 0; i < v.length; i++) {
+                bv.put12('F', cw.newFloat(v[i]).index);
+            }
+        } else if (value instanceof double[]) {
+            double[] v = (double[]) value;
+            bv.put12('[', v.length);
+            for (int i = 0; i < v.length; i++) {
+                bv.put12('D', cw.newDouble(v[i]).index);
+            }
+        } else {
+            Item i = cw.newConstItem(value);
+            bv.put12(".s.IFJDCS".charAt(i.type), i.index);
+        }
+    }
+
+    @Override
+    public void visitEnum(final String name, final String desc,
+            final String value) {
+        ++size;
+        if (named) {
+            bv.putShort(cw.newUTF8(name));
+        }
+        bv.put12('e', cw.newUTF8(desc)).putShort(cw.newUTF8(value));
+    }
+
+    @Override
+    public AnnotationVisitor visitAnnotation(final String name,
+            final String desc) {
+        ++size;
+        if (named) {
+            bv.putShort(cw.newUTF8(name));
+        }
+        // write tag and type, and reserve space for values count
+        bv.put12('@', cw.newUTF8(desc)).putShort(0);
+        return new AnnotationWriter(cw, true, bv, bv, bv.length - 2);
+    }
+
+    @Override
+    public AnnotationVisitor visitArray(final String name) {
+        ++size;
+        if (named) {
+            bv.putShort(cw.newUTF8(name));
+        }
+        // write tag, and reserve space for array size
+        bv.put12('[', 0);
+        return new AnnotationWriter(cw, false, bv, bv, bv.length - 2);
+    }
+
+    @Override
+    public void visitEnd() {
+        if (parent != null) {
+            byte[] data = parent.data;
+            data[offset] = (byte) (size >>> 8);
+            data[offset + 1] = (byte) size;
+        }
+    }
+
+    // ------------------------------------------------------------------------
+    // Utility methods
+    // ------------------------------------------------------------------------
+
+    /**
+     * Returns the size of this annotation writer list.
+     *
+     * @return the size of this annotation writer list.
+     */
+    int getSize() {
+        int size = 0;
+        AnnotationWriter aw = this;
+        while (aw != null) {
+            size += aw.bv.length;
+            aw = aw.next;
+        }
+        return size;
+    }
+
+    /**
+     * Puts the annotations of this annotation writer list into the given byte
+     * vector.
+     *
+     * @param out
+     *            where the annotations must be put.
+     */
+    void put(final ByteVector out) {
+        int n = 0;
+        int size = 2;
+        AnnotationWriter aw = this;
+        AnnotationWriter last = null;
+        while (aw != null) {
+            ++n;
+            size += aw.bv.length;
+            aw.visitEnd(); // in case user forgot to call visitEnd
+            aw.prev = last;
+            last = aw;
+            aw = aw.next;
+        }
+        out.putInt(size);
+        out.putShort(n);
+        aw = last;
+        while (aw != null) {
+            out.putByteArray(aw.bv.data, 0, aw.bv.length);
+            aw = aw.prev;
+        }
+    }
+
+    /**
+     * Puts the given annotation lists into the given byte vector.
+     *
+     * @param panns
+     *            an array of annotation writer lists.
+     * @param off
+     *            index of the first annotation to be written.
+     * @param out
+     *            where the annotations must be put.
+     */
+    static void put(final AnnotationWriter[] panns, final int off,
+            final ByteVector out) {
+        int size = 1 + 2 * (panns.length - off);
+        for (int i = off; i < panns.length; ++i) {
+            size += panns[i] == null ? 0 : panns[i].getSize();
+        }
+        out.putInt(size).putByte(panns.length - off);
+        for (int i = off; i < panns.length; ++i) {
+            AnnotationWriter aw = panns[i];
+            AnnotationWriter last = null;
+            int n = 0;
+            while (aw != null) {
+                ++n;
+                aw.visitEnd(); // in case user forgot to call visitEnd
+                aw.prev = last;
+                last = aw;
+                aw = aw.next;
+            }
+            out.putShort(n);
+            aw = last;
+            while (aw != null) {
+                out.putByteArray(aw.bv.data, 0, aw.bv.length);
+                aw = aw.prev;
+            }
+        }
+    }
+
+    /**
+     * Puts the given type reference and type path into the given bytevector.
+     * LOCAL_VARIABLE and RESOURCE_VARIABLE target types are not supported.
+     *
+     * @param typeRef
+     *            a reference to the annotated type. See {@link TypeReference}.
+     * @param typePath
+     *            the path to the annotated type argument, wildcard bound, array
+     *            element type, or static inner type within 'typeRef'. May be
+     *            &#60;tt&#62;null&#60;/tt&#62; if the annotation targets 'typeRef' as a whole.
+     * @param out
+     *            where the type reference and type path must be put.
+     */
+    static void putTarget(int typeRef, TypePath typePath, ByteVector out) {
+        switch (typeRef >>> 24) {
+        case 0x00: // CLASS_TYPE_PARAMETER
+        case 0x01: // METHOD_TYPE_PARAMETER
+        case 0x16: // METHOD_FORMAL_PARAMETER
+            out.putShort(typeRef >>> 16);
+            break;
+        case 0x13: // FIELD
+        case 0x14: // METHOD_RETURN
+        case 0x15: // METHOD_RECEIVER
+            out.putByte(typeRef >>> 24);
+            break;
+        case 0x47: // CAST
+        case 0x48: // CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT
+        case 0x49: // METHOD_INVOCATION_TYPE_ARGUMENT
+        case 0x4A: // CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT
+        case 0x4B: // METHOD_REFERENCE_TYPE_ARGUMENT
+            out.putInt(typeRef);
+            break;
+        // case 0x10: // CLASS_EXTENDS
+        // case 0x11: // CLASS_TYPE_PARAMETER_BOUND
+        // case 0x12: // METHOD_TYPE_PARAMETER_BOUND
+        // case 0x17: // THROWS
+        // case 0x42: // EXCEPTION_PARAMETER
+        // case 0x43: // INSTANCEOF
+        // case 0x44: // NEW
+        // case 0x45: // CONSTRUCTOR_REFERENCE
+        // case 0x46: // METHOD_REFERENCE
+        default:
+            out.put12(typeRef >>> 24, (typeRef & 0xFFFF00) >> 8);
+            break;
+        }
+        if (typePath == null) {
+            out.putByte(0);
+        } else {
+            int length = typePath.b[typePath.offset] * 2 + 1;
+            out.putByteArray(typePath.b, typePath.offset, length);
+        }
+    }
+}

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

@@ -0,0 +1,364 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+import java.util.Arrays;
+
+/**
+ * A non standard class, field, method or code attribute.
+ *
+ * @author Eric Bruneton
+ * @author Eugene Kuleshov
+ */
+public class Attribute {
+
+    /**
+     * The type of this attribute.
+     */
+    public final String type;
+
+    /**
+     * The raw value of this attribute, used only for unknown attributes.
+     */
+    byte[] value;
+
+    /**
+     * The next attribute in this attribute list. May be <tt>null</tt>.
+     */
+    Attribute next;
+
+    /**
+     * Constructs a new empty attribute.
+     *
+     * @param type
+     *            the type of the attribute.
+     */
+    protected Attribute(final String type) {
+        this.type = type;
+    }
+
+    /**
+     * Returns <tt>true</tt> if this type of attribute is unknown. The default
+     * implementation of this method always returns <tt>true</tt>.
+     *
+     * @return <tt>true</tt> if this type of attribute is unknown.
+     */
+    public boolean isUnknown() {
+        return true;
+    }
+
+    /**
+     * Returns <tt>true</tt> if this type of attribute is a code attribute.
+     *
+     * @return <tt>true</tt> if this type of attribute is a code attribute.
+     */
+    public boolean isCodeAttribute() {
+        return false;
+    }
+
+    /**
+     * Returns the labels corresponding to this attribute.
+     *
+     * @return the labels corresponding to this attribute, or <tt>null</tt> if
+     *         this attribute is not a code attribute that contains labels.
+     */
+    protected Label[] getLabels() {
+        return null;
+    }
+
+    /**
+     * Reads a {@link #type type} attribute. This method must return a
+     * <i>new</i> {@link Attribute} object, of type {@link #type type},
+     * corresponding to the &#60;tt&#62;len&#60;/tt&#62; bytes starting at the given offset, in
+     * the given class reader.
+     *
+     * @param cr
+     *            the class that contains the attribute to be read.
+     * @param off
+     *            index of the first byte of the attribute's content in
+     *            {@link ClassReader#b cr.b}. The 6 attribute header bytes,
+     *            containing the type and the length of the attribute, are not
+     *            taken into account here.
+     * @param len
+     *            the length of the attribute's content.
+     * @param buf
+     *            buffer to be used to call {@link ClassReader#readUTF8
+     *            readUTF8}, {@link ClassReader#readClass(int,char[]) readClass}
+     *            or {@link ClassReader#readConst readConst}.
+     * @param codeOff
+     *            index of the first byte of code's attribute content in
+     *            {@link ClassReader#b cr.b}, or -1 if the attribute to be read
+     *            is not a code attribute. The 6 attribute header bytes,
+     *            containing the type and the length of the attribute, are not
+     *            taken into account here.
+     * @param labels
+     *            the labels of the method's code, or &#60;tt&#62;null&#60;/tt&#62; if the
+     *            attribute to be read is not a code attribute.
+     * @return a <i>new</i> {@link Attribute} object corresponding to the given
+     *         bytes.
+     */
+    protected Attribute read(final ClassReader cr, final int off,
+            final int len, final char[] buf, final int codeOff,
+            final Label[] labels) {
+        Attribute attr = new Attribute(type);
+        attr.value = new byte[len];
+        System.arraycopy(cr.b, off, attr.value, 0, len);
+        return attr;
+    }
+
+    /**
+     * Returns the byte array form of this attribute.
+     *
+     * @param cw
+     *            the class to which this attribute must be added. This
+     *            parameter can be used to add to the constant pool of this
+     *            class the items that corresponds to this attribute.
+     * @param code
+     *            the bytecode of the method corresponding to this code
+     *            attribute, or &#60;tt&#62;null&#60;/tt&#62; if this attribute is not a code
+     *            attributes.
+     * @param len
+     *            the length of the bytecode of the method corresponding to this
+     *            code attribute, or &#60;tt&#62;null&#60;/tt&#62; if this attribute is not a
+     *            code attribute.
+     * @param maxStack
+     *            the maximum stack size of the method corresponding to this
+     *            code attribute, or -1 if this attribute is not a code
+     *            attribute.
+     * @param maxLocals
+     *            the maximum number of local variables of the method
+     *            corresponding to this code attribute, or -1 if this attribute
+     *            is not a code attribute.
+     * @return the byte array form of this attribute.
+     */
+    protected ByteVector write(final ClassWriter cw, final byte[] code,
+            final int len, final int maxStack, final int maxLocals) {
+        ByteVector v = new ByteVector();
+        v.data = value;
+        v.length = value.length;
+        return v;
+    }
+
+    /**
+     * Returns the length of the attribute list that begins with this attribute.
+     *
+     * @return the length of the attribute list that begins with this attribute.
+     */
+    final int getCount() {
+        int count = 0;
+        Attribute attr = this;
+        while (attr != null) {
+            count += 1;
+            attr = attr.next;
+        }
+        return count;
+    }
+
+    /**
+     * Returns the size of all the attributes in this attribute list.
+     *
+     * @param cw
+     *            the class writer to be used to convert the attributes into
+     *            byte arrays, with the {@link #write write} method.
+     * @param code
+     *            the bytecode of the method corresponding to these code
+     *            attributes, or &#60;tt&#62;null&#60;/tt&#62; if these attributes are not code
+     *            attributes.
+     * @param len
+     *            the length of the bytecode of the method corresponding to
+     *            these code attributes, or &#60;tt&#62;null&#60;/tt&#62; if these attributes
+     *            are not code attributes.
+     * @param maxStack
+     *            the maximum stack size of the method corresponding to these
+     *            code attributes, or -1 if these attributes are not code
+     *            attributes.
+     * @param maxLocals
+     *            the maximum number of local variables of the method
+     *            corresponding to these code attributes, or -1 if these
+     *            attributes are not code attributes.
+     * @return the size of all the attributes in this attribute list. This size
+     *         includes the size of the attribute headers.
+     */
+    final int getSize(final ClassWriter cw, final byte[] code, final int len,
+            final int maxStack, final int maxLocals) {
+        Attribute attr = this;
+        int size = 0;
+        while (attr != null) {
+            cw.newUTF8(attr.type);
+            size += attr.write(cw, code, len, maxStack, maxLocals).length + 6;
+            attr = attr.next;
+        }
+        return size;
+    }
+
+    /**
+     * Writes all the attributes of this attribute list in the given byte
+     * vector.
+     *
+     * @param cw
+     *            the class writer to be used to convert the attributes into
+     *            byte arrays, with the {@link #write write} method.
+     * @param code
+     *            the bytecode of the method corresponding to these code
+     *            attributes, or &#60;tt&#62;null&#60;/tt&#62; if these attributes are not code
+     *            attributes.
+     * @param len
+     *            the length of the bytecode of the method corresponding to
+     *            these code attributes, or &#60;tt&#62;null&#60;/tt&#62; if these attributes
+     *            are not code attributes.
+     * @param maxStack
+     *            the maximum stack size of the method corresponding to these
+     *            code attributes, or -1 if these attributes are not code
+     *            attributes.
+     * @param maxLocals
+     *            the maximum number of local variables of the method
+     *            corresponding to these code attributes, or -1 if these
+     *            attributes are not code attributes.
+     * @param out
+     *            where the attributes must be written.
+     */
+    final void put(final ClassWriter cw, final byte[] code, final int len,
+            final int maxStack, final int maxLocals, final ByteVector out) {
+        Attribute attr = this;
+        while (attr != null) {
+            ByteVector b = attr.write(cw, code, len, maxStack, maxLocals);
+            out.putShort(cw.newUTF8(attr.type)).putInt(b.length);
+            out.putByteArray(b.data, 0, b.length);
+            attr = attr.next;
+        }
+    }
+
+    //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");
+        }
+
+        byte[] bytes;
+        String[] classes;
+
+        @Override
+        protected Attribute read(ClassReader cr, int off, int len, char[] buf, int codeOff, Label[] labels) {
+            int offset = off;
+            NestMembers a = new NestMembers();
+            int size = cr.readShort(off);
+            a.classes = new String[size];
+            off += 2;
+            for (int i = 0; i < size ; i++) {
+                a.classes[i] = cr.readClass(off, buf);
+                off += 2;
+            }
+            a.bytes = Arrays.copyOfRange(cr.b, offset, offset + len);
+            return a;
+        }
+
+        @Override
+        protected ByteVector write(ClassWriter cw, byte[] code, int len, int maxStack, int maxLocals) {
+            ByteVector v = new ByteVector(bytes.length);
+            v.putShort(classes.length);
+            for (String s : classes) {
+                v.putShort(cw.newClass(s));
+            }
+            return v;
+        }
+    }
+
+    /**
+     * 
+     */
+    public static class NestHost extends Attribute {
+
+        byte[] bytes;
+        String clazz;
+        /**
+         * 
+         */
+        public NestHost() {
+            super("NestHost");
+        }
+
+        @Override
+        protected Attribute read(ClassReader cr, int off, int len, char[] buf, int codeOff, Label[] labels) {
+            int offset = off;
+            NestHost a = new NestHost();
+            a.clazz = cr.readClass(off, buf);
+            a.bytes = Arrays.copyOfRange(cr.b, offset, offset + len);
+            return a;
+        }
+
+        @Override
+        protected ByteVector write(ClassWriter cw, byte[] code, int len, int maxStack, int maxLocals) {
+            ByteVector v = new ByteVector(bytes.length);
+            v.putShort(cw.newClass(clazz));
+            return v;
+        }
+    }
+
+    static final Attribute[] DEFAULT_ATTRIBUTE_PROTOS = new Attribute[] {
+        new NestMembers(),
+        new NestHost()
+    };
+}

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

@@ -0,0 +1,368 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+/**
+ * A dynamically extensible vector of bytes. This class is roughly equivalent to
+ * a DataOutputStream on top of a ByteArrayOutputStream, but is more efficient.
+ *
+ * @author Eric Bruneton
+ */
+public class ByteVector {
+
+    /**
+     * The content of this vector.
+     */
+    byte[] data;
+
+    /**
+     * Actual number of bytes in this vector.
+     */
+    int length;
+
+    /**
+     * Constructs a new {@link ByteVector ByteVector} with a default initial
+     * size.
+     */
+    public ByteVector() {
+        data = new byte[64];
+    }
+
+    /**
+     * Constructs a new {@link ByteVector ByteVector} with the given initial
+     * size.
+     *
+     * @param initialSize
+     *            the initial size of the byte vector to be constructed.
+     */
+    public ByteVector(final int initialSize) {
+        data = new byte[initialSize];
+    }
+
+    /**
+     * Puts a byte into this byte vector. The byte vector is automatically
+     * enlarged if necessary.
+     *
+     * @param b
+     *            a byte.
+     * @return this byte vector.
+     */
+    public ByteVector putByte(final int b) {
+        int length = this.length;
+        if (length + 1 > data.length) {
+            enlarge(1);
+        }
+        data[length++] = (byte) b;
+        this.length = length;
+        return this;
+    }
+
+    /**
+     * Puts two bytes into this byte vector. The byte vector is automatically
+     * enlarged if necessary.
+     *
+     * @param b1
+     *            a byte.
+     * @param b2
+     *            another byte.
+     * @return this byte vector.
+     */
+    ByteVector put11(final int b1, final int b2) {
+        int length = this.length;
+        if (length + 2 > data.length) {
+            enlarge(2);
+        }
+        byte[] data = this.data;
+        data[length++] = (byte) b1;
+        data[length++] = (byte) b2;
+        this.length = length;
+        return this;
+    }
+
+    /**
+     * Puts a short into this byte vector. The byte vector is automatically
+     * enlarged if necessary.
+     *
+     * @param s
+     *            a short.
+     * @return this byte vector.
+     */
+    public ByteVector putShort(final int s) {
+        int length = this.length;
+        if (length + 2 > data.length) {
+            enlarge(2);
+        }
+        byte[] data = this.data;
+        data[length++] = (byte) (s >>> 8);
+        data[length++] = (byte) s;
+        this.length = length;
+        return this;
+    }
+
+    /**
+     * Puts a byte and a short into this byte vector. The byte vector is
+     * automatically enlarged if necessary.
+     *
+     * @param b
+     *            a byte.
+     * @param s
+     *            a short.
+     * @return this byte vector.
+     */
+    ByteVector put12(final int b, final int s) {
+        int length = this.length;
+        if (length + 3 > data.length) {
+            enlarge(3);
+        }
+        byte[] data = this.data;
+        data[length++] = (byte) b;
+        data[length++] = (byte) (s >>> 8);
+        data[length++] = (byte) s;
+        this.length = length;
+        return this;
+    }
+
+    /**
+     * Puts an int into this byte vector. The byte vector is automatically
+     * enlarged if necessary.
+     *
+     * @param i
+     *            an int.
+     * @return this byte vector.
+     */
+    public ByteVector putInt(final int i) {
+        int length = this.length;
+        if (length + 4 > data.length) {
+            enlarge(4);
+        }
+        byte[] data = this.data;
+        data[length++] = (byte) (i >>> 24);
+        data[length++] = (byte) (i >>> 16);
+        data[length++] = (byte) (i >>> 8);
+        data[length++] = (byte) i;
+        this.length = length;
+        return this;
+    }
+
+    /**
+     * Puts a long into this byte vector. The byte vector is automatically
+     * enlarged if necessary.
+     *
+     * @param l
+     *            a long.
+     * @return this byte vector.
+     */
+    public ByteVector putLong(final long l) {
+        int length = this.length;
+        if (length + 8 > data.length) {
+            enlarge(8);
+        }
+        byte[] data = this.data;
+        int i = (int) (l >>> 32);
+        data[length++] = (byte) (i >>> 24);
+        data[length++] = (byte) (i >>> 16);
+        data[length++] = (byte) (i >>> 8);
+        data[length++] = (byte) i;
+        i = (int) l;
+        data[length++] = (byte) (i >>> 24);
+        data[length++] = (byte) (i >>> 16);
+        data[length++] = (byte) (i >>> 8);
+        data[length++] = (byte) i;
+        this.length = length;
+        return this;
+    }
+
+    /**
+     * Puts an UTF8 string into this byte vector. The byte vector is
+     * automatically enlarged if necessary.
+     *
+     * @param s
+     *            a String whose UTF8 encoded length must be less than 65536.
+     * @return this byte vector.
+     */
+    public ByteVector putUTF8(final String s) {
+        int charLength = s.length();
+        if (charLength > 65535) {
+            throw new IllegalArgumentException();
+        }
+        int len = length;
+        if (len + 2 + charLength > data.length) {
+            enlarge(2 + charLength);
+        }
+        byte[] data = this.data;
+        // optimistic algorithm: instead of computing the byte length and then
+        // serializing the string (which requires two loops), we assume the byte
+        // length is equal to char length (which is the most frequent case), and
+        // we start serializing the string right away. During the serialization,
+        // if we find that this assumption is wrong, we continue with the
+        // general method.
+        data[len++] = (byte) (charLength >>> 8);
+        data[len++] = (byte) charLength;
+        for (int i = 0; i < charLength; ++i) {
+            char c = s.charAt(i);
+            if (c >= '\001' && c <= '\177') {
+                data[len++] = (byte) c;
+            } else {
+                length = len;
+                return encodeUTF8(s, i, 65535);
+            }
+        }
+        length = len;
+        return this;
+    }
+
+    /**
+     * Puts an UTF8 string into this byte vector. The byte vector is
+     * automatically enlarged if necessary. The string length is encoded in two
+     * bytes before the encoded characters, if there is space for that (i.e. if
+     * this.length - i - 2 >= 0).
+     *
+     * @param s
+     *            the String to encode.
+     * @param i
+     *            the index of the first character to encode. The previous
+     *            characters are supposed to have already been encoded, using
+     *            only one byte per character.
+     * @param maxByteLength
+     *            the maximum byte length of the encoded string, including the
+     *            already encoded characters.
+     * @return this byte vector.
+     */
+    ByteVector encodeUTF8(final String s, int i, int maxByteLength) {
+        int charLength = s.length();
+        int byteLength = i;
+        char c;
+        for (int j = i; j < charLength; ++j) {
+            c = s.charAt(j);
+            if (c >= '\001' && c <= '\177') {
+                byteLength++;
+            } else if (c > '\u07FF') {
+                byteLength += 3;
+            } else {
+                byteLength += 2;
+            }
+        }
+        if (byteLength > maxByteLength) {
+            throw new IllegalArgumentException();
+        }
+        int start = length - i - 2;
+        if (start >= 0) {
+          data[start] = (byte) (byteLength >>> 8);
+          data[start + 1] = (byte) byteLength;
+        }
+        if (length + byteLength - i > data.length) {
+            enlarge(byteLength - i);
+        }
+        int len = length;
+        for (int j = i; j < charLength; ++j) {
+            c = s.charAt(j);
+            if (c >= '\001' && c <= '\177') {
+                data[len++] = (byte) c;
+            } else if (c > '\u07FF') {
+                data[len++] = (byte) (0xE0 | c >> 12 & 0xF);
+                data[len++] = (byte) (0x80 | c >> 6 & 0x3F);
+                data[len++] = (byte) (0x80 | c & 0x3F);
+            } else {
+                data[len++] = (byte) (0xC0 | c >> 6 & 0x1F);
+                data[len++] = (byte) (0x80 | c & 0x3F);
+            }
+        }
+        length = len;
+        return this;
+    }
+
+    /**
+     * Puts an array of bytes into this byte vector. The byte vector is
+     * automatically enlarged if necessary.
+     *
+     * @param b
+     *            an array of bytes. May be &#60;tt&#62;null&#60;/tt&#62; to put &#60;tt&#62;len&#60;/tt&#62;
+     *            null bytes into this byte vector.
+     * @param off
+     *            index of the fist byte of b that must be copied.
+     * @param len
+     *            number of bytes of b that must be copied.
+     * @return this byte vector.
+     */
+    public ByteVector putByteArray(final byte[] b, final int off, final int len) {
+        if (length + len > data.length) {
+            enlarge(len);
+        }
+        if (b != null) {
+            System.arraycopy(b, off, data, length, len);
+        }
+        length += len;
+        return this;
+    }
+
+    /**
+     * Enlarge this byte vector so that it can receive n more bytes.
+     *
+     * @param size
+     *            number of additional bytes that this byte vector should be
+     *            able to receive.
+     */
+    private void enlarge(final int size) {
+        int length1 = 2 * data.length;
+        int length2 = length + size;
+        byte[] newData = new byte[length1 > length2 ? length1 : length2];
+        System.arraycopy(data, 0, newData, 0, length);
+        data = newData;
+    }
+}

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

@@ -0,0 +1,365 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+/**
+ * A visitor to visit a Java class. The methods of this class must be called in
+ * the following order: <tt>visit</tt> [ <tt>visitSource</tt> ] [
+ * <tt>visitModule</tt> ][ <tt>visitOuterClass</tt> ] ( <tt>visitAnnotation</tt> |
+ * <tt>visitTypeAnnotation</tt> | <tt>visitAttribute</tt> )* (
+ * <tt>visitInnerClass</tt> | <tt>visitField</tt> | <tt>visitMethod</tt> )*
+ * <tt>visitEnd</tt>.
+ *
+ * @author Eric Bruneton
+ */
+public abstract class ClassVisitor {
+
+    /**
+     * The ASM API version implemented by this visitor. The value of this field
+     * must be one of {@link Opcodes#ASM4}, {@link Opcodes#ASM5} or {@link Opcodes#ASM6}.
+     */
+    protected final int api;
+
+    /**
+     * The class visitor to which this visitor must delegate method calls. May
+     * be null.
+     */
+    protected ClassVisitor cv;
+
+    /**
+     * Constructs a new {@link ClassVisitor}.
+     *
+     * @param api
+     *            the ASM API version implemented by this visitor. Must be one
+     *            of {@link Opcodes#ASM4}, {@link Opcodes#ASM5} or {@link Opcodes#ASM6}.
+     */
+    public ClassVisitor(final int api) {
+        this(api, null);
+    }
+
+    /**
+     * Constructs a new {@link ClassVisitor}.
+     *
+     * @param api
+     *            the ASM API version implemented by this visitor. Must be one
+     *            of {@link Opcodes#ASM4}, {@link Opcodes#ASM5} or {@link Opcodes#ASM6}.
+     * @param cv
+     *            the class visitor to which this visitor must delegate method
+     *            calls. May be null.
+     */
+    public ClassVisitor(final int api, final ClassVisitor cv) {
+        this.api = api;
+        this.cv = cv;
+    }
+
+    /**
+     * Visits the header of the class.
+     *
+     * @param version
+     *            the class version.
+     * @param access
+     *            the class's access flags (see {@link Opcodes}). This parameter
+     *            also indicates if the class is deprecated.
+     * @param name
+     *            the internal name of the class (see
+     *            {@link Type#getInternalName() getInternalName}).
+     * @param signature
+     *            the signature of this class. May be <tt>null</tt> if the class
+     *            is not a generic one, and does not extend or implement generic
+     *            classes or interfaces.
+     * @param superName
+     *            the internal of name of the super class (see
+     *            {@link Type#getInternalName() getInternalName}). For
+     *            interfaces, the super class is {@link Object}. May be
+     *            <tt>null</tt>, but only for the {@link Object} class.
+     * @param interfaces
+     *            the internal names of the class's interfaces (see
+     *            {@link Type#getInternalName() getInternalName}). May be
+     *            <tt>null</tt>.
+     */
+    public void visit(int version, int access, String name, String signature,
+            String superName, String[] interfaces) {
+        if (cv != null) {
+            cv.visit(version, access, name, signature, superName, interfaces);
+        }
+    }
+
+    /**
+     * Visits the source of the class.
+     *
+     * @param source
+     *            the name of the source file from which the class was compiled.
+     *            May be <tt>null</tt>.
+     * @param debug
+     *            additional debug information to compute the correspondance
+     *            between source and compiled elements of the class. May be
+     *            <tt>null</tt>.
+     */
+    public void visitSource(String source, String debug) {
+        if (cv != null) {
+            cv.visitSource(source, debug);
+        }
+    }
+
+    /**
+     * Visit the module corresponding to the class.
+     * @param name
+     *            module name
+     * @param access
+     *            module flags, among {@code ACC_OPEN}, {@code ACC_SYNTHETIC}
+     *            and {@code ACC_MANDATED}.
+     * @param version
+     *            module version or null.
+     * @return a visitor to visit the module values, or <tt>null</tt> if
+     *         this visitor is not interested in visiting this module.
+     */
+    public ModuleVisitor visitModule(String name, int access, String version) {
+        if (api < Opcodes.ASM6) {
+            throw new RuntimeException();
+        }
+        if (cv != null) {
+            return cv.visitModule(name, access, version);
+        }
+        return null;
+    }
+
+    /**
+     * Visits the enclosing class of the class. This method must be called only
+     * if the class has an enclosing class.
+     *
+     * @param owner
+     *            internal name of the enclosing class of the class.
+     * @param name
+     *            the name of the method that contains the class, or
+     *            &#60;tt&#62;null&#60;/tt&#62; if the class is not enclosed in a method of its
+     *            enclosing class.
+     * @param desc
+     *            the descriptor of the method that contains the class, or
+     *            &#60;tt&#62;null&#60;/tt&#62; if the class is not enclosed in a method of its
+     *            enclosing class.
+     */
+    public void visitOuterClass(String owner, String name, String desc) {
+        if (cv != null) {
+            cv.visitOuterClass(owner, name, desc);
+        }
+    }
+
+    /**
+     * Visits an annotation of the class.
+     *
+     * @param desc
+     *            the class descriptor of the annotation class.
+     * @param visible
+     *            &#60;tt&#62;true&#60;/tt&#62; if the annotation is visible at runtime.
+     * @return a visitor to visit the annotation values, or &#60;tt&#62;null&#60;/tt&#62; if
+     *         this visitor is not interested in visiting this annotation.
+     */
+    public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+        if (cv != null) {
+            return cv.visitAnnotation(desc, visible);
+        }
+        return null;
+    }
+
+    /**
+     * Visits an annotation on a type in the class signature.
+     *
+     * @param typeRef
+     *            a reference to the annotated type. The sort of this type
+     *            reference must be {@link TypeReference#CLASS_TYPE_PARAMETER
+     *            CLASS_TYPE_PARAMETER},
+     *            {@link TypeReference#CLASS_TYPE_PARAMETER_BOUND
+     *            CLASS_TYPE_PARAMETER_BOUND} or
+     *            {@link TypeReference#CLASS_EXTENDS CLASS_EXTENDS}. See
+     *            {@link TypeReference}.
+     * @param typePath
+     *            the path to the annotated type argument, wildcard bound, array
+     *            element type, or static inner type within 'typeRef'. May be
+     *            &#60;tt&#62;null&#60;/tt&#62; if the annotation targets 'typeRef' as a whole.
+     * @param desc
+     *            the class descriptor of the annotation class.
+     * @param visible
+     *            &#60;tt&#62;true&#60;/tt&#62; if the annotation is visible at runtime.
+     * @return a visitor to visit the annotation values, or &#60;tt&#62;null&#60;/tt&#62; if
+     *         this visitor is not interested in visiting this annotation.
+     */
+    public AnnotationVisitor visitTypeAnnotation(int typeRef,
+            TypePath typePath, String desc, boolean visible) {
+        if (cv != null) {
+            return cv.visitTypeAnnotation(typeRef, typePath, desc, visible);
+        }
+        return null;
+    }
+
+    /**
+     * Visits a non standard attribute of the class.
+     *
+     * @param attr
+     *            an attribute.
+     */
+    public void visitAttribute(Attribute attr) {
+        if (cv != null) {
+            cv.visitAttribute(attr);
+        }
+    }
+
+    /**
+     * Visits information about an inner class. This inner class is not
+     * necessarily a member of the class being visited.
+     *
+     * @param name
+     *            the internal name of an inner class (see
+     *            {@link Type#getInternalName() getInternalName}).
+     * @param outerName
+     *            the internal name of the class to which the inner class
+     *            belongs (see {@link Type#getInternalName() getInternalName}).
+     *            May be &#60;tt&#62;null&#60;/tt&#62; for not member classes.
+     * @param innerName
+     *            the (simple) name of the inner class inside its enclosing
+     *            class. May be &#60;tt&#62;null&#60;/tt&#62; for anonymous inner classes.
+     * @param access
+     *            the access flags of the inner class as originally declared in
+     *            the enclosing class.
+     */
+    public void visitInnerClass(String name, String outerName,
+            String innerName, int access) {
+        if (cv != null) {
+            cv.visitInnerClass(name, outerName, innerName, access);
+        }
+    }
+
+    /**
+     * Visits a field of the class.
+     *
+     * @param access
+     *            the field's access flags (see {@link Opcodes}). This parameter
+     *            also indicates if the field is synthetic and/or deprecated.
+     * @param name
+     *            the field's name.
+     * @param desc
+     *            the field's descriptor (see {@link Type Type}).
+     * @param signature
+     *            the field's signature. May be &#60;tt&#62;null&#60;/tt&#62; if the field's
+     *            type does not use generic types.
+     * @param value
+     *            the field's initial value. This parameter, which may be
+     *            &#60;tt&#62;null&#60;/tt&#62; if the field does not have an initial value,
+     *            must be an {@link Integer}, a {@link Float}, a {@link Long}, a
+     *            {@link Double} or a {@link String} (for &#60;tt&#62;int&#60;/tt&#62;,
+     *            &#60;tt&#62;float&#60;/tt&#62;, &#60;tt&#62;long&#60;/tt&#62; or &#60;tt&#62;String&#60;/tt&#62; fields
+     *            respectively). <i>This parameter is only used for static
+     *            fields</i>. Its value is ignored for non static fields, which
+     *            must be initialized through bytecode instructions in
+     *            constructors or methods.
+     * @return a visitor to visit field annotations and attributes, or
+     *         &#60;tt&#62;null&#60;/tt&#62; if this class visitor is not interested in visiting
+     *         these annotations and attributes.
+     */
+    public FieldVisitor visitField(int access, String name, String desc,
+            String signature, Object value) {
+        if (cv != null) {
+            return cv.visitField(access, name, desc, signature, value);
+        }
+        return null;
+    }
+
+    /**
+     * Visits a method of the class. This method <i>must</i> return a new
+     * {@link MethodVisitor} instance (or &#60;tt&#62;null&#60;/tt&#62;) each time it is called,
+     * i.e., it should not return a previously returned visitor.
+     *
+     * @param access
+     *            the method's access flags (see {@link Opcodes}). This
+     *            parameter also indicates if the method is synthetic and/or
+     *            deprecated.
+     * @param name
+     *            the method's name.
+     * @param desc
+     *            the method's descriptor (see {@link Type Type}).
+     * @param signature
+     *            the method's signature. May be &#60;tt&#62;null&#60;/tt&#62; if the method
+     *            parameters, return type and exceptions do not use generic
+     *            types.
+     * @param exceptions
+     *            the internal names of the method's exception classes (see
+     *            {@link Type#getInternalName() getInternalName}). May be
+     *            &#60;tt&#62;null&#60;/tt&#62;.
+     * @return an object to visit the byte code of the method, or &#60;tt&#62;null&#60;/tt&#62;
+     *         if this class visitor is not interested in visiting the code of
+     *         this method.
+     */
+    public MethodVisitor visitMethod(int access, String name, String desc,
+            String signature, String[] exceptions) {
+        if (cv != null) {
+            return cv.visitMethod(access, name, desc, signature, exceptions);
+        }
+        return null;
+    }
+
+    /**
+     * Visits the end of the class. This method, which is the last one to be
+     * called, is used to inform the visitor that all the fields and methods of
+     * the class have been visited.
+     */
+    public void visitEnd() {
+        if (cv != null) {
+            cv.visitEnd();
+        }
+    }
+}

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

@@ -0,0 +1,174 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.redkale.asm;
+
+/**
+ * Information about a class being parsed in a {@link ClassReader}.
+ *
+ * @author Eric Bruneton
+ */
+class Context {
+
+    /**
+     * Prototypes of the attributes that must be parsed for this class.
+     */
+    Attribute[] attrs;
+
+    /**
+     * The {@link ClassReader} option flags for the parsing of this class.
+     */
+    int flags;
+
+    /**
+     * The buffer used to read strings.
+     */
+    char[] buffer;
+
+    /**
+     * The start index of each bootstrap method.
+     */
+    int[] bootstrapMethods;
+
+    /**
+     * The access flags of the method currently being parsed.
+     */
+    int access;
+
+    /**
+     * The name of the method currently being parsed.
+     */
+    String name;
+
+    /**
+     * The descriptor of the method currently being parsed.
+     */
+    String desc;
+
+    /**
+     * The label objects, indexed by bytecode offset, of the method currently
+     * being parsed (only bytecode offsets for which a label is needed have a
+     * non null associated Label object).
+     */
+    Label[] labels;
+
+    /**
+     * The target of the type annotation currently being parsed.
+     */
+    int typeRef;
+
+    /**
+     * The path of the type annotation currently being parsed.
+     */
+    TypePath typePath;
+
+    /**
+     * The offset of the latest stack map frame that has been parsed.
+     */
+    int offset;
+
+    /**
+     * The labels corresponding to the start of the local variable ranges in the
+     * local variable type annotation currently being parsed.
+     */
+    Label[] start;
+
+    /**
+     * The labels corresponding to the end of the local variable ranges in the
+     * local variable type annotation currently being parsed.
+     */
+    Label[] end;
+
+    /**
+     * The local variable indices for each local variable range in the local
+     * variable type annotation currently being parsed.
+     */
+    int[] index;
+
+    /**
+     * The encoding of the latest stack map frame that has been parsed.
+     */
+    int mode;
+
+    /**
+     * The number of locals in the latest stack map frame that has been parsed.
+     */
+    int localCount;
+
+    /**
+     * The number locals in the latest stack map frame that has been parsed,
+     * minus the number of locals in the previous frame.
+     */
+    int localDiff;
+
+    /**
+     * The local values of the latest stack map frame that has been parsed.
+     */
+    Object[] local;
+
+    /**
+     * The stack size of the latest stack map frame that has been parsed.
+     */
+    int stackCount;
+
+    /**
+     * The stack values of the latest stack map frame that has been parsed.
+     */
+    Object[] stack;
+}

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

@@ -0,0 +1,85 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.redkale.asm;
+
+/**
+ * Information about the input stack map frame at the "current" instruction of a
+ * method. This is implemented as a Frame subclass for a "basic block"
+ * containing only one instruction.
+ *
+ * @author Eric Bruneton
+ */
+class CurrentFrame extends Frame {
+
+    /**
+     * Sets this CurrentFrame to the input stack map frame of the next "current"
+     * instruction, i.e. the instruction just after the given one. It is assumed
+     * that the value of this object when this method is called is the stack map
+     * frame status just before the given instruction is executed.
+     */
+    @Override
+    void execute(int opcode, int arg, ClassWriter cw, Item item) {
+        super.execute(opcode, arg, cw, item);
+        Frame successor = new Frame();
+        merge(cw, successor, 0);
+        set(successor);
+        owner.inputStackTop = 0;
+    }
+}

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

@@ -0,0 +1,104 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+/**
+ * An edge in the control flow graph of a method body. See {@link Label Label}.
+ *
+ * @author Eric Bruneton
+ */
+class Edge {
+
+    /**
+     * Denotes a normal control flow graph edge.
+     */
+    static final int NORMAL = 0;
+
+    /**
+     * Denotes a control flow graph edge corresponding to an exception handler.
+     * More precisely any {@link Edge} whose {@link #info} is strictly positive
+     * corresponds to an exception handler. The actual value of {@link #info} is
+     * the index, in the {@link ClassWriter} type table, of the exception that
+     * is catched.
+     */
+    static final int EXCEPTION = 0x7FFFFFFF;
+
+    /**
+     * Information about this control flow graph edge. If
+     * {@link ClassWriter#COMPUTE_MAXS} is used this field is the (relative)
+     * stack size in the basic block from which this edge originates. This size
+     * is equal to the stack size at the "jump" instruction to which this edge
+     * corresponds, relatively to the stack size at the beginning of the
+     * originating basic block. If {@link ClassWriter#COMPUTE_FRAMES} is used,
+     * this field is the kind of this control flow graph edge (i.e. NORMAL or
+     * EXCEPTION).
+     */
+    int info;
+
+    /**
+     * The successor block of the basic block from which this edge originates.
+     */
+    Label successor;
+
+    /**
+     * The next edge in the list of successors of the originating basic block.
+     * See {@link Label#successors successors}.
+     */
+    Edge next;
+}

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

@@ -0,0 +1,173 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+/**
+ * A visitor to visit a Java field. The methods of this class must be called in
+ * the following order: ( <tt>visitAnnotation</tt> |
+ * <tt>visitTypeAnnotation</tt> | <tt>visitAttribute</tt> )* <tt>visitEnd</tt>.
+ *
+ * @author Eric Bruneton
+ */
+public abstract class FieldVisitor {
+
+    /**
+     * The ASM API version implemented by this visitor. The value of this field
+     * must be one of {@link Opcodes#ASM4}, {@link Opcodes#ASM5} or {@link Opcodes#ASM6}.
+     */
+    protected final int api;
+
+    /**
+     * The field visitor to which this visitor must delegate method calls. May
+     * be null.
+     */
+    protected FieldVisitor fv;
+
+    /**
+     * Constructs a new {@link FieldVisitor}.
+     *
+     * @param api
+     *            the ASM API version implemented by this visitor. Must be one
+     *            of {@link Opcodes#ASM4}, {@link Opcodes#ASM5} or {@link Opcodes#ASM6}.
+     */
+    public FieldVisitor(final int api) {
+        this(api, null);
+    }
+
+    /**
+     * Constructs a new {@link FieldVisitor}.
+     *
+     * @param api
+     *            the ASM API version implemented by this visitor. Must be one
+     *            of {@link Opcodes#ASM4}, {@link Opcodes#ASM5} or {@link Opcodes#ASM6}.
+     * @param fv
+     *            the field visitor to which this visitor must delegate method
+     *            calls. May be null.
+     */
+    public FieldVisitor(final int api, final FieldVisitor fv) {
+        this.api = api;
+        this.fv = fv;
+    }
+
+    /**
+     * Visits an annotation of the field.
+     *
+     * @param desc
+     *            the class descriptor of the annotation class.
+     * @param visible
+     *            <tt>true</tt> if the annotation is visible at runtime.
+     * @return a visitor to visit the annotation values, or <tt>null</tt> if
+     *         this visitor is not interested in visiting this annotation.
+     */
+    public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+        if (fv != null) {
+            return fv.visitAnnotation(desc, visible);
+        }
+        return null;
+    }
+
+    /**
+     * Visits an annotation on the type of the field.
+     *
+     * @param typeRef
+     *            a reference to the annotated type. The sort of this type
+     *            reference must be {@link TypeReference#FIELD FIELD}. See
+     *            {@link TypeReference}.
+     * @param typePath
+     *            the path to the annotated type argument, wildcard bound, array
+     *            element type, or static inner type within 'typeRef'. May be
+     *            <tt>null</tt> if the annotation targets 'typeRef' as a whole.
+     * @param desc
+     *            the class descriptor of the annotation class.
+     * @param visible
+     *            <tt>true</tt> if the annotation is visible at runtime.
+     * @return a visitor to visit the annotation values, or <tt>null</tt> if
+     *         this visitor is not interested in visiting this annotation.
+     */
+    public AnnotationVisitor visitTypeAnnotation(int typeRef,
+            TypePath typePath, String desc, boolean visible) {
+        if (fv != null) {
+            return fv.visitTypeAnnotation(typeRef, typePath, desc, visible);
+        }
+        return null;
+    }
+
+    /**
+     * Visits a non standard attribute of the field.
+     *
+     * @param attr
+     *            an attribute.
+     */
+    public void visitAttribute(Attribute attr) {
+        if (fv != null) {
+            fv.visitAttribute(attr);
+        }
+    }
+
+    /**
+     * Visits the end of the field. This method, which is the last one to be
+     * called, is used to inform the visitor that all the annotations and
+     * attributes of the field have been visited.
+     */
+    public void visitEnd() {
+        if (fv != null) {
+            fv.visitEnd();
+        }
+    }
+}

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

@@ -0,0 +1,352 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+/**
+ * An {@link FieldVisitor} that generates Java fields in bytecode form.
+ *
+ * @author Eric Bruneton
+ */
+final class FieldWriter extends FieldVisitor {
+
+    /**
+     * The class writer to which this field must be added.
+     */
+    private final ClassWriter cw;
+
+    /**
+     * Access flags of this field.
+     */
+    private final int access;
+
+    /**
+     * The index of the constant pool item that contains the name of this
+     * method.
+     */
+    private final int name;
+
+    /**
+     * The index of the constant pool item that contains the descriptor of this
+     * field.
+     */
+    private final int desc;
+
+    /**
+     * The index of the constant pool item that contains the signature of this
+     * field.
+     */
+    private int signature;
+
+    /**
+     * The index of the constant pool item that contains the constant value of
+     * this field.
+     */
+    private int value;
+
+    /**
+     * The runtime visible annotations of this field. May be <tt>null</tt>.
+     */
+    private AnnotationWriter anns;
+
+    /**
+     * The runtime invisible annotations of this field. May be <tt>null</tt>.
+     */
+    private AnnotationWriter ianns;
+
+    /**
+     * The runtime visible type annotations of this field. May be <tt>null</tt>.
+     */
+    private AnnotationWriter tanns;
+
+    /**
+     * The runtime invisible type annotations of this field. May be
+     * <tt>null</tt>.
+     */
+    private AnnotationWriter itanns;
+
+    /**
+     * The non standard attributes of this field. May be <tt>null</tt>.
+     */
+    private Attribute attrs;
+
+    // ------------------------------------------------------------------------
+    // Constructor
+    // ------------------------------------------------------------------------
+
+    /**
+     * Constructs a new {@link FieldWriter}.
+     *
+     * @param cw
+     *            the class writer to which this field must be added.
+     * @param access
+     *            the field's access flags (see {@link Opcodes}).
+     * @param name
+     *            the field's name.
+     * @param desc
+     *            the field's descriptor (see {@link Type}).
+     * @param signature
+     *            the field's signature. May be <tt>null</tt>.
+     * @param value
+     *            the field's constant value. May be <tt>null</tt>.
+     */
+    FieldWriter(final ClassWriter cw, final int access, final String name,
+            final String desc, final String signature, final Object value) {
+        super(Opcodes.ASM6);
+        if (cw.firstField == null) {
+            cw.firstField = this;
+        } else {
+            cw.lastField.fv = this;
+        }
+        cw.lastField = this;
+        this.cw = cw;
+        this.access = access;
+        this.name = cw.newUTF8(name);
+        this.desc = cw.newUTF8(desc);
+        if (signature != null) {
+            this.signature = cw.newUTF8(signature);
+        }
+        if (value != null) {
+            this.value = cw.newConstItem(value).index;
+        }
+    }
+
+    // ------------------------------------------------------------------------
+    // Implementation of the FieldVisitor abstract class
+    // ------------------------------------------------------------------------
+
+    @Override
+    public AnnotationVisitor visitAnnotation(final String desc,
+            final boolean visible) {
+        ByteVector bv = new ByteVector();
+        // write type, and reserve space for values count
+        bv.putShort(cw.newUTF8(desc)).putShort(0);
+        AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv, 2);
+        if (visible) {
+            aw.next = anns;
+            anns = aw;
+        } else {
+            aw.next = ianns;
+            ianns = aw;
+        }
+        return aw;
+    }
+
+    @Override
+    public AnnotationVisitor visitTypeAnnotation(final int typeRef,
+            final TypePath typePath, final String desc, final boolean visible) {
+        ByteVector bv = new ByteVector();
+        // write target_type and target_info
+        AnnotationWriter.putTarget(typeRef, typePath, bv);
+        // write type, and reserve space for values count
+        bv.putShort(cw.newUTF8(desc)).putShort(0);
+        AnnotationWriter aw = new AnnotationWriter(cw, true, bv, bv,
+                bv.length - 2);
+        if (visible) {
+            aw.next = tanns;
+            tanns = aw;
+        } else {
+            aw.next = itanns;
+            itanns = aw;
+        }
+        return aw;
+    }
+
+    @Override
+    public void visitAttribute(final Attribute attr) {
+        attr.next = attrs;
+        attrs = attr;
+    }
+
+    @Override
+    public void visitEnd() {
+    }
+
+    // ------------------------------------------------------------------------
+    // Utility methods
+    // ------------------------------------------------------------------------
+
+    /**
+     * Returns the size of this field.
+     *
+     * @return the size of this field.
+     */
+    int getSize() {
+        int size = 8;
+        if (value != 0) {
+            cw.newUTF8("ConstantValue");
+            size += 8;
+        }
+        if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
+            if ((cw.version & 0xFFFF) < Opcodes.V1_5
+                    || (access & ClassWriter.ACC_SYNTHETIC_ATTRIBUTE) != 0) {
+                cw.newUTF8("Synthetic");
+                size += 6;
+            }
+        }
+        if ((access & Opcodes.ACC_DEPRECATED) != 0) {
+            cw.newUTF8("Deprecated");
+            size += 6;
+        }
+        if (signature != 0) {
+            cw.newUTF8("Signature");
+            size += 8;
+        }
+        if (anns != null) {
+            cw.newUTF8("RuntimeVisibleAnnotations");
+            size += 8 + anns.getSize();
+        }
+        if (ianns != null) {
+            cw.newUTF8("RuntimeInvisibleAnnotations");
+            size += 8 + ianns.getSize();
+        }
+        if (tanns != null) {
+            cw.newUTF8("RuntimeVisibleTypeAnnotations");
+            size += 8 + tanns.getSize();
+        }
+        if (itanns != null) {
+            cw.newUTF8("RuntimeInvisibleTypeAnnotations");
+            size += 8 + itanns.getSize();
+        }
+        if (attrs != null) {
+            size += attrs.getSize(cw, null, 0, -1, -1);
+        }
+        return size;
+    }
+
+    /**
+     * Puts the content of this field into the given byte vector.
+     *
+     * @param out
+     *            where the content of this field must be put.
+     */
+    void put(final ByteVector out) {
+        final int FACTOR = ClassWriter.TO_ACC_SYNTHETIC;
+        int mask = Opcodes.ACC_DEPRECATED | ClassWriter.ACC_SYNTHETIC_ATTRIBUTE
+                | ((access & ClassWriter.ACC_SYNTHETIC_ATTRIBUTE) / FACTOR);
+        out.putShort(access & ~mask).putShort(name).putShort(desc);
+        int attributeCount = 0;
+        if (value != 0) {
+            ++attributeCount;
+        }
+        if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
+            if ((cw.version & 0xFFFF) < Opcodes.V1_5
+                    || (access & ClassWriter.ACC_SYNTHETIC_ATTRIBUTE) != 0) {
+                ++attributeCount;
+            }
+        }
+        if ((access & Opcodes.ACC_DEPRECATED) != 0) {
+            ++attributeCount;
+        }
+        if (signature != 0) {
+            ++attributeCount;
+        }
+        if (anns != null) {
+            ++attributeCount;
+        }
+        if (ianns != null) {
+            ++attributeCount;
+        }
+        if (tanns != null) {
+            ++attributeCount;
+        }
+        if (itanns != null) {
+            ++attributeCount;
+        }
+        if (attrs != null) {
+            attributeCount += attrs.getCount();
+        }
+        out.putShort(attributeCount);
+        if (value != 0) {
+            out.putShort(cw.newUTF8("ConstantValue"));
+            out.putInt(2).putShort(value);
+        }
+        if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
+            if ((cw.version & 0xFFFF) < Opcodes.V1_5
+                    || (access & ClassWriter.ACC_SYNTHETIC_ATTRIBUTE) != 0) {
+                out.putShort(cw.newUTF8("Synthetic")).putInt(0);
+            }
+        }
+        if ((access & Opcodes.ACC_DEPRECATED) != 0) {
+            out.putShort(cw.newUTF8("Deprecated")).putInt(0);
+        }
+        if (signature != 0) {
+            out.putShort(cw.newUTF8("Signature"));
+            out.putInt(2).putShort(signature);
+        }
+        if (anns != null) {
+            out.putShort(cw.newUTF8("RuntimeVisibleAnnotations"));
+            anns.put(out);
+        }
+        if (ianns != null) {
+            out.putShort(cw.newUTF8("RuntimeInvisibleAnnotations"));
+            ianns.put(out);
+        }
+        if (tanns != null) {
+            out.putShort(cw.newUTF8("RuntimeVisibleTypeAnnotations"));
+            tanns.put(out);
+        }
+        if (itanns != null) {
+            out.putShort(cw.newUTF8("RuntimeInvisibleTypeAnnotations"));
+            itanns.put(out);
+        }
+        if (attrs != null) {
+            attrs.put(cw, null, 0, -1, -1, out);
+        }
+    }
+}

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

@@ -0,0 +1,222 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.redkale.asm;
+
+/**
+ * A reference to a field or a method.
+ *
+ * @author Remi Forax
+ * @author Eric Bruneton
+ */
+public final class Handle {
+
+    /**
+     * The kind of field or method designated by this Handle. Should 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}.
+     */
+    final int tag;
+
+    /**
+     * The internal name of the class that owns the field or method designated
+     * by this handle.
+     */
+    final String owner;
+
+    /**
+     * The name of the field or method designated by this handle.
+     */
+    final String name;
+
+    /**
+     * The descriptor of the field or method designated by this handle.
+     */
+    final String desc;
+
+
+    /**
+     * Indicate if the owner is an interface or not.
+     */
+    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.
+     * @param itf
+     *            true if the owner is an interface.
+     */
+    public Handle(int tag, String owner, String name, String desc, boolean itf) {
+        this.tag = tag;
+        this.owner = owner;
+        this.name = name;
+        this.desc = desc;
+        this.itf = itf;
+    }
+
+    /**
+     * Returns the kind of field or method designated by this handle.
+     *
+     * @return {@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}.
+     */
+    public int getTag() {
+        return tag;
+    }
+
+    /**
+     * Returns the internal name of the class that owns the field or method
+     * designated by this handle.
+     *
+     * @return the internal name of the class that owns the field or method
+     *         designated by this handle.
+     */
+    public String getOwner() {
+        return owner;
+    }
+
+    /**
+     * Returns the name of the field or method designated by this handle.
+     *
+     * @return the name of the field or method designated by this handle.
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Returns the descriptor of the field or method designated by this handle.
+     *
+     * @return the descriptor of the field or method designated by this handle.
+     */
+    public String getDesc() {
+        return desc;
+    }
+
+    /**
+     * Returns true if the owner of the field or method designated
+     * by this handle is an interface.
+     *
+     * @return true if the owner of the field or method designated
+     *         by this handle is an interface.
+     */
+    public boolean isInterface() {
+        return itf;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof Handle)) {
+            return false;
+        }
+        Handle h = (Handle) obj;
+        return tag == h.tag && itf == h.itf && owner.equals(h.owner)
+                && name.equals(h.name) && desc.equals(h.desc);
+    }
+
+    @Override
+    public int hashCode() {
+        return tag + (itf? 64: 0) + owner.hashCode() * name.hashCode() * desc.hashCode();
+    }
+
+    /**
+     * Returns the textual representation of this handle. The textual
+     * representation is:
+     *
+     * <pre>
+     * for a reference to a class:
+     * owner '.' name desc ' ' '(' tag ')'
+     * for a reference to an interface:
+     * owner '.' name desc ' ' '(' tag ' ' itf ')'
+     * </pre>
+     *
+     * . As this format is unambiguous, it can be parsed if necessary.
+     */
+    @Override
+    public String toString() {
+        return owner + '.' + name + desc + " (" + tag + (itf? " itf": "") + ')';
+    }
+}

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

@@ -0,0 +1,150 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+/**
+ * Information about an exception handler block.
+ *
+ * @author Eric Bruneton
+ */
+class Handler {
+
+    /**
+     * Beginning of the exception handler's scope (inclusive).
+     */
+    Label start;
+
+    /**
+     * End of the exception handler's scope (exclusive).
+     */
+    Label end;
+
+    /**
+     * Beginning of the exception handler's code.
+     */
+    Label handler;
+
+    /**
+     * Internal name of the type of exceptions handled by this handler, or
+     * <tt>null</tt> to catch any exceptions.
+     */
+    String desc;
+
+    /**
+     * Constant pool index of the internal name of the type of exceptions
+     * handled by this handler, or 0 to catch any exceptions.
+     */
+    int type;
+
+    /**
+     * Next exception handler block info.
+     */
+    Handler next;
+
+    /**
+     * Removes the range between start and end from the given exception
+     * handlers.
+     *
+     * @param h
+     *            an exception handler list.
+     * @param start
+     *            the start of the range to be removed.
+     * @param end
+     *            the end of the range to be removed. Maybe null.
+     * @return the exception handler list with the start-end range removed.
+     */
+    static Handler remove(Handler h, Label start, Label end) {
+        if (h == null) {
+            return null;
+        } else {
+            h.next = remove(h.next, start, end);
+        }
+        int hstart = h.start.position;
+        int hend = h.end.position;
+        int s = start.position;
+        int e = end == null ? Integer.MAX_VALUE : end.position;
+        // if [hstart,hend[ and [s,e[ intervals intersect...
+        if (s < hend && e > hstart) {
+            if (s <= hstart) {
+                if (e >= hend) {
+                    // [hstart,hend[ fully included in [s,e[, h removed
+                    h = h.next;
+                } else {
+                    // [hstart,hend[ minus [s,e[ = [e,hend[
+                    h.start = end;
+                }
+            } else if (e >= hend) {
+                // [hstart,hend[ minus [s,e[ = [hstart,s[
+                h.end = start;
+            } else {
+                // [hstart,hend[ minus [s,e[ = [hstart,s[ + [e,hend[
+                Handler g = new Handler();
+                g.start = end;
+                g.end = h.end;
+                g.handler = h.handler;
+                g.desc = h.desc;
+                g.type = h.type;
+                g.next = h.next;
+                h.end = start;
+                h.next = g;
+            }
+        }
+        return h;
+    }
+}

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

@@ -0,0 +1,347 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+/**
+ * A constant pool item. Constant pool items can be created with the 'newXXX'
+ * methods in the {@link ClassWriter} class.
+ *
+ * @author Eric Bruneton
+ */
+final class Item {
+
+    /**
+     * Index of this item in the constant pool.
+     */
+    int index;
+
+    /**
+     * Type of this constant pool item. A single class is used to represent all
+     * constant pool item types, in order to minimize the bytecode size of this
+     * package. The value of this field is one of {@link ClassWriter#INT},
+     * {@link ClassWriter#LONG}, {@link ClassWriter#FLOAT},
+     * {@link ClassWriter#DOUBLE}, {@link ClassWriter#UTF8},
+     * {@link ClassWriter#STR}, {@link ClassWriter#CLASS},
+     * {@link ClassWriter#NAME_TYPE}, {@link ClassWriter#FIELD},
+     * {@link ClassWriter#METH}, {@link ClassWriter#IMETH},
+     * {@link ClassWriter#MODULE}, {@link ClassWriter#PACKAGE},
+     * {@link ClassWriter#MTYPE}, {@link ClassWriter#INDY}.
+     *
+     * MethodHandle constant 9 variations are stored using a range of 9 values
+     * from {@link ClassWriter#HANDLE_BASE} + 1 to
+     * {@link ClassWriter#HANDLE_BASE} + 9.
+     *
+     * Special Item types are used for Items that are stored in the ClassWriter
+     * {@link ClassWriter#typeTable}, instead of the constant pool, in order to
+     * avoid clashes with normal constant pool items in the ClassWriter constant
+     * pool's hash table. These special item types are
+     * {@link ClassWriter#TYPE_NORMAL}, {@link ClassWriter#TYPE_UNINIT} and
+     * {@link ClassWriter#TYPE_MERGED}.
+     */
+    int type;
+
+    /**
+     * Value of this item, for an integer item.
+     */
+    int intVal;
+
+    /**
+     * Value of this item, for a long item.
+     */
+    long longVal;
+
+    /**
+     * First part of the value of this item, for items that do not hold a
+     * primitive value.
+     */
+    String strVal1;
+
+    /**
+     * Second part of the value of this item, for items that do not hold a
+     * primitive value.
+     */
+    String strVal2;
+
+    /**
+     * Third part of the value of this item, for items that do not hold a
+     * primitive value.
+     */
+    String strVal3;
+
+    /**
+     * The hash code value of this constant pool item.
+     */
+    int hashCode;
+
+    /**
+     * Link to another constant pool item, used for collision lists in the
+     * constant pool's hash table.
+     */
+    Item next;
+
+    /**
+     * Constructs an uninitialized {@link Item}.
+     */
+    Item() {
+    }
+
+    /**
+     * Constructs an uninitialized {@link Item} for constant pool element at
+     * given position.
+     *
+     * @param index
+     *            index of the item to be constructed.
+     */
+    Item(final int index) {
+        this.index = index;
+    }
+
+    /**
+     * Constructs a copy of the given item.
+     *
+     * @param index
+     *            index of the item to be constructed.
+     * @param i
+     *            the item that must be copied into the item to be constructed.
+     */
+    Item(final int index, final Item i) {
+        this.index = index;
+        type = i.type;
+        intVal = i.intVal;
+        longVal = i.longVal;
+        strVal1 = i.strVal1;
+        strVal2 = i.strVal2;
+        strVal3 = i.strVal3;
+        hashCode = i.hashCode;
+    }
+
+    /**
+     * Sets this item to an integer item.
+     *
+     * @param intVal
+     *            the value of this item.
+     */
+    void set(final int intVal) {
+        this.type = ClassWriter.INT;
+        this.intVal = intVal;
+        this.hashCode = 0x7FFFFFFF & (type + intVal);
+    }
+
+    /**
+     * Sets this item to a long item.
+     *
+     * @param longVal
+     *            the value of this item.
+     */
+    void set(final long longVal) {
+        this.type = ClassWriter.LONG;
+        this.longVal = longVal;
+        this.hashCode = 0x7FFFFFFF & (type + (int) longVal);
+    }
+
+    /**
+     * Sets this item to a float item.
+     *
+     * @param floatVal
+     *            the value of this item.
+     */
+    void set(final float floatVal) {
+        this.type = ClassWriter.FLOAT;
+        this.intVal = Float.floatToRawIntBits(floatVal);
+        this.hashCode = 0x7FFFFFFF & (type + (int) floatVal);
+    }
+
+    /**
+     * Sets this item to a double item.
+     *
+     * @param doubleVal
+     *            the value of this item.
+     */
+    void set(final double doubleVal) {
+        this.type = ClassWriter.DOUBLE;
+        this.longVal = Double.doubleToRawLongBits(doubleVal);
+        this.hashCode = 0x7FFFFFFF & (type + (int) doubleVal);
+    }
+
+    /**
+     * Sets this item to an item that do not hold a primitive value.
+     *
+     * @param type
+     *            the type of this item.
+     * @param strVal1
+     *            first part of the value of this item.
+     * @param strVal2
+     *            second part of the value of this item.
+     * @param strVal3
+     *            third part of the value of this item.
+     */
+    @SuppressWarnings("fallthrough")
+    void set(final int type, final String strVal1, final String strVal2,
+            final String strVal3) {
+        this.type = type;
+        this.strVal1 = strVal1;
+        this.strVal2 = strVal2;
+        this.strVal3 = strVal3;
+        switch (type) {
+        case ClassWriter.CLASS:
+            this.intVal = 0;     // intVal of a class must be zero, see visitInnerClass
+        case ClassWriter.UTF8:
+        case ClassWriter.STR:
+        case ClassWriter.MTYPE:
+        case ClassWriter.MODULE:
+        case ClassWriter.PACKAGE:
+        case ClassWriter.TYPE_NORMAL:
+            hashCode = 0x7FFFFFFF & (type + strVal1.hashCode());
+            return;
+        case ClassWriter.NAME_TYPE: {
+            hashCode = 0x7FFFFFFF & (type + strVal1.hashCode()
+                    * strVal2.hashCode());
+            return;
+        }
+        // ClassWriter.FIELD:
+        // ClassWriter.METH:
+        // ClassWriter.IMETH:
+        // ClassWriter.HANDLE_BASE + 1..9
+        default:
+            hashCode = 0x7FFFFFFF & (type + strVal1.hashCode()
+                    * strVal2.hashCode() * strVal3.hashCode());
+        }
+    }
+
+    /**
+     * Sets the item to an InvokeDynamic item.
+     *
+     * @param name
+     *            invokedynamic's name.
+     * @param desc
+     *            invokedynamic's desc.
+     * @param bsmIndex
+     *            zero based index into the class attribute BootrapMethods.
+     */
+    void set(String name, String desc, int bsmIndex) {
+        this.type = ClassWriter.INDY;
+        this.longVal = bsmIndex;
+        this.strVal1 = name;
+        this.strVal2 = desc;
+        this.hashCode = 0x7FFFFFFF & (ClassWriter.INDY + bsmIndex
+                * strVal1.hashCode() * strVal2.hashCode());
+    }
+
+    /**
+     * Sets the item to a BootstrapMethod item.
+     *
+     * @param position
+     *            position in byte in the class attribute BootrapMethods.
+     * @param hashCode
+     *            hashcode of the item. This hashcode is processed from the
+     *            hashcode of the bootstrap method and the hashcode of all
+     *            bootstrap arguments.
+     */
+    void set(int position, int hashCode) {
+        this.type = ClassWriter.BSM;
+        this.intVal = position;
+        this.hashCode = hashCode;
+    }
+
+    /**
+     * Indicates if the given item is equal to this one. <i>This method assumes
+     * that the two items have the same {@link #type}</i>.
+     *
+     * @param i
+     *            the item to be compared to this one. Both items must have the
+     *            same {@link #type}.
+     * @return &#60;tt&#62;true&#60;/tt&#62; if the given item if equal to this one,
+     *         &#60;tt&#62;false&#60;/tt&#62; otherwise.
+     */
+    boolean isEqualTo(final Item i) {
+        switch (type) {
+        case ClassWriter.UTF8:
+        case ClassWriter.STR:
+        case ClassWriter.CLASS:
+        case ClassWriter.MODULE:
+        case ClassWriter.PACKAGE:
+        case ClassWriter.MTYPE:
+        case ClassWriter.TYPE_NORMAL:
+            return i.strVal1.equals(strVal1);
+        case ClassWriter.TYPE_MERGED:
+        case ClassWriter.LONG:
+        case ClassWriter.DOUBLE:
+            return i.longVal == longVal;
+        case ClassWriter.INT:
+        case ClassWriter.FLOAT:
+            return i.intVal == intVal;
+        case ClassWriter.TYPE_UNINIT:
+            return i.intVal == intVal && i.strVal1.equals(strVal1);
+        case ClassWriter.NAME_TYPE:
+            return i.strVal1.equals(strVal1) && i.strVal2.equals(strVal2);
+        case ClassWriter.INDY: {
+            return i.longVal == longVal && i.strVal1.equals(strVal1)
+                    && i.strVal2.equals(strVal2);
+        }
+        // case ClassWriter.FIELD:
+        // case ClassWriter.METH:
+        // case ClassWriter.IMETH:
+        // case ClassWriter.HANDLE_BASE + 1..9
+        default:
+            return i.strVal1.equals(strVal1) && i.strVal2.equals(strVal2)
+                    && i.strVal3.equals(strVal3);
+        }
+    }
+
+}

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

@@ -0,0 +1,593 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+/**
+ * A label represents a position in the bytecode of a method. Labels are used
+ * for jump, goto, and switch instructions, and for try catch blocks. A label
+ * designates the <i>instruction</i> that is just after. Note however that there
+ * can be other elements between a label and the instruction it designates (such
+ * as other labels, stack map frames, line numbers, etc.).
+ *
+ * @author Eric Bruneton
+ */
+public class Label {
+
+    /**
+     * Indicates if this label is only used for debug attributes. Such a label
+     * is not the start of a basic block, the target of a jump instruction, or
+     * an exception handler. It can be safely ignored in control flow graph
+     * analysis algorithms (for optimization purposes).
+     */
+    static final int DEBUG = 1;
+
+    /**
+     * Indicates if the position of this label is known.
+     */
+    static final int RESOLVED = 2;
+
+    /**
+     * Indicates if this label has been updated, after instruction resizing.
+     */
+    static final int RESIZED = 4;
+
+    /**
+     * Indicates if this basic block has been pushed in the basic block stack.
+     * See {@link MethodWriter#visitMaxs visitMaxs}.
+     */
+    static final int PUSHED = 8;
+
+    /**
+     * Indicates if this label is the target of a jump instruction, or the start
+     * of an exception handler.
+     */
+    static final int TARGET = 16;
+
+    /**
+     * Indicates if a stack map frame must be stored for this label.
+     */
+    static final int STORE = 32;
+
+    /**
+     * Indicates if this label corresponds to a reachable basic block.
+     */
+    static final int REACHABLE = 64;
+
+    /**
+     * Indicates if this basic block ends with a JSR instruction.
+     */
+    static final int JSR = 128;
+
+    /**
+     * Indicates if this basic block ends with a RET instruction.
+     */
+    static final int RET = 256;
+
+    /**
+     * Indicates if this basic block is the start of a subroutine.
+     */
+    static final int SUBROUTINE = 512;
+
+    /**
+     * Indicates if this subroutine basic block has been visited by a
+     * visitSubroutine(null, ...) call.
+     */
+    static final int VISITED = 1024;
+
+    /**
+     * Indicates if this subroutine basic block has been visited by a
+     * visitSubroutine(!null, ...) call.
+     */
+    static final int VISITED2 = 2048;
+
+    /**
+     * Field used to associate user information to a label. Warning: this field
+     * is used by the ASM tree package. In order to use it with the ASM tree
+     * package you must override the
+     * 
+     */
+    public Object info;
+
+    /**
+     * Flags that indicate the status of this label.
+     *
+     * @see #DEBUG
+     * @see #RESOLVED
+     * @see #RESIZED
+     * @see #PUSHED
+     * @see #TARGET
+     * @see #STORE
+     * @see #REACHABLE
+     * @see #JSR
+     * @see #RET
+     */
+    int status;
+
+    /**
+     * The line number corresponding to this label, if known. If there are
+     * several lines, each line is stored in a separate label, all linked via
+     * their next field (these links are created in ClassReader and removed just
+     * before visitLabel is called, so that this does not impact the rest of the
+     * code).
+     */
+    int line;
+
+    /**
+     * The position of this label in the code, if known.
+     */
+    int position;
+
+    /**
+     * Number of forward references to this label, times two.
+     */
+    private int referenceCount;
+
+    /**
+     * Informations about forward references. Each forward reference is
+     * described by two consecutive integers in this array: the first one is the
+     * position of the first byte of the bytecode instruction that contains the
+     * forward reference, while the second is the position of the first byte of
+     * the forward reference itself. In fact the sign of the first integer
+     * indicates if this reference uses 2 or 4 bytes, and its absolute value
+     * gives the position of the bytecode instruction. This array is also used
+     * as a bitset to store the subroutines to which a basic block belongs. This
+     * information is needed in {@linked MethodWriter#visitMaxs}, after all
+     * forward references have been resolved. Hence the same array can be used
+     * for both purposes without problems.
+     */
+    private int[] srcAndRefPositions;
+
+    // ------------------------------------------------------------------------
+
+    /*
+     * Fields for the control flow and data flow graph analysis algorithms (used
+     * to compute the maximum stack size or the stack map frames). A control
+     * flow graph contains one node per "basic block", and one edge per "jump"
+     * from one basic block to another. Each node (i.e., each basic block) is
+     * represented by the Label object that corresponds to the first instruction
+     * of this basic block. Each node also stores the list of its successors in
+     * the graph, as a linked list of Edge objects.
+     *
+     * The control flow analysis algorithms used to compute the maximum stack
+     * size or the stack map frames are similar and use two steps. The first
+     * step, during the visit of each instruction, builds information about the
+     * state of the local variables and the operand stack at the end of each
+     * basic block, called the "output frame", <i>relatively</i> to the frame
+     * state at the beginning of the basic block, which is called the "input
+     * frame", and which is <i>unknown</i> during this step. The second step, in
+     * {@link MethodWriter#visitMaxs}, is a fix point algorithm that computes
+     * information about the input frame of each basic block, from the input
+     * state of the first basic block (known from the method signature), and by
+     * the using the previously computed relative output frames.
+     *
+     * The algorithm used to compute the maximum stack size only computes the
+     * relative output and absolute input stack heights, while the algorithm
+     * used to compute stack map frames computes relative output frames and
+     * absolute input frames.
+     */
+
+    /**
+     * Start of the output stack relatively to the input stack. The exact
+     * semantics of this field depends on the algorithm that is used.
+     *
+     * When only the maximum stack size is computed, this field is the number of
+     * elements in the input stack.
+     *
+     * When the stack map frames are completely computed, this field is the
+     * offset of the first output stack element relatively to the top of the
+     * input stack. This offset is always negative or null. A null offset means
+     * that the output stack must be appended to the input stack. A -n offset
+     * means that the first n output stack elements must replace the top n input
+     * stack elements, and that the other elements must be appended to the input
+     * stack.
+     */
+    int inputStackTop;
+
+    /**
+     * Maximum height reached by the output stack, relatively to the top of the
+     * input stack. This maximum is always positive or null.
+     */
+    int outputStackMax;
+
+    /**
+     * Information about the input and output stack map frames of this basic
+     * block. This field is only used when {@link ClassWriter#COMPUTE_FRAMES}
+     * option is used.
+     */
+    Frame frame;
+
+    /**
+     * The successor of this label, in the order they are visited. This linked
+     * list does not include labels used for debug info only. If
+     * {@link ClassWriter#COMPUTE_FRAMES} option is used then, in addition, it
+     * does not contain successive labels that denote the same bytecode position
+     * (in this case only the first label appears in this list).
+     */
+    Label successor;
+
+    /**
+     * The successors of this node in the control flow graph. These successors
+     * are stored in a linked list of {@link Edge Edge} objects, linked to each
+     * other by their {@link Edge#next} field.
+     */
+    Edge successors;
+
+    /**
+     * The next basic block in the basic block stack. This stack is used in the
+     * main loop of the fix point algorithm used in the second step of the
+     * control flow analysis algorithms. It is also used in
+     * {@link #visitSubroutine} to avoid using a recursive method, and in
+     * ClassReader to temporarily store multiple source lines for a label.
+     *
+     * @see MethodWriter#visitMaxs
+     */
+    Label next;
+
+    // ------------------------------------------------------------------------
+    // Constructor
+    // ------------------------------------------------------------------------
+
+    /**
+     * Constructs a new label.
+     */
+    public Label() {
+    }
+
+    // ------------------------------------------------------------------------
+    // Methods to compute offsets and to manage forward references
+    // ------------------------------------------------------------------------
+
+    /**
+     * Returns the offset corresponding to this label. This offset is computed
+     * from the start of the method's bytecode. <i>This method is intended for
+     * {@link Attribute} sub classes, and is normally not needed by class
+     * generators or adapters.</i>
+     *
+     * @return the offset corresponding to this label.
+     * @throws IllegalStateException
+     *             if this label is not resolved yet.
+     */
+    public int getOffset() {
+        if ((status & RESOLVED) == 0) {
+            throw new IllegalStateException(
+                    "Label offset position has not been resolved yet");
+        }
+        return position;
+    }
+
+    /**
+     * Puts a reference to this label in the bytecode of a method. If the
+     * position of the label is known, the offset is computed and written
+     * directly. Otherwise, a null offset is written and a new forward reference
+     * is declared for this label.
+     *
+     * @param owner
+     *            the code writer that calls this method.
+     * @param out
+     *            the bytecode of the method.
+     * @param source
+     *            the position of first byte of the bytecode instruction that
+     *            contains this label.
+     * @param wideOffset
+     *            &#60;tt&#62;true&#60;/tt&#62; if the reference must be stored in 4 bytes, or
+     *            &#60;tt&#62;false&#60;/tt&#62; if it must be stored with 2 bytes.
+     * @throws IllegalArgumentException
+     *             if this label has not been created by the given code writer.
+     */
+    void put(final MethodWriter owner, final ByteVector out, final int source,
+            final boolean wideOffset) {
+        if ((status & RESOLVED) == 0) {
+            if (wideOffset) {
+                addReference(-1 - source, out.length);
+                out.putInt(-1);
+            } else {
+                addReference(source, out.length);
+                out.putShort(-1);
+            }
+        } else {
+            if (wideOffset) {
+                out.putInt(position - source);
+            } else {
+                out.putShort(position - source);
+            }
+        }
+    }
+
+    /**
+     * Adds a forward reference to this label. This method must be called only
+     * for a true forward reference, i.e. only if this label is not resolved
+     * yet. For backward references, the offset of the reference can be, and
+     * must be, computed and stored directly.
+     *
+     * @param sourcePosition
+     *            the position of the referencing instruction. This position
+     *            will be used to compute the offset of this forward reference.
+     * @param referencePosition
+     *            the position where the offset for this forward reference must
+     *            be stored.
+     */
+    private void addReference(final int sourcePosition,
+            final int referencePosition) {
+        if (srcAndRefPositions == null) {
+            srcAndRefPositions = new int[6];
+        }
+        if (referenceCount >= srcAndRefPositions.length) {
+            int[] a = new int[srcAndRefPositions.length + 6];
+            System.arraycopy(srcAndRefPositions, 0, a, 0,
+                    srcAndRefPositions.length);
+            srcAndRefPositions = a;
+        }
+        srcAndRefPositions[referenceCount++] = sourcePosition;
+        srcAndRefPositions[referenceCount++] = referencePosition;
+    }
+
+    /**
+     * Resolves all forward references to this label. This method must be called
+     * when this label is added to the bytecode of the method, i.e. when its
+     * position becomes known. This method fills in the blanks that where left
+     * in the bytecode by each forward reference previously added to this label.
+     *
+     * @param owner
+     *            the code writer that calls this method.
+     * @param position
+     *            the position of this label in the bytecode.
+     * @param data
+     *            the bytecode of the method.
+     * @return &#60;tt&#62;true&#60;/tt&#62; if a blank that was left for this label was too
+     *         small to store the offset. In such a case the corresponding jump
+     *         instruction is replaced with a pseudo instruction (using unused
+     *         opcodes) using an unsigned two bytes offset. These pseudo
+     *         instructions will be replaced with standard bytecode instructions
+     *         with wider offsets (4 bytes instead of 2), in ClassReader.
+     * @throws IllegalArgumentException
+     *             if this label has already been resolved, or if it has not
+     *             been created by the given code writer.
+     */
+    boolean resolve(final MethodWriter owner, final int position,
+            final byte[] data) {
+        boolean needUpdate = false;
+        this.status |= RESOLVED;
+        this.position = position;
+        int i = 0;
+        while (i < referenceCount) {
+            int source = srcAndRefPositions[i++];
+            int reference = srcAndRefPositions[i++];
+            int offset;
+            if (source >= 0) {
+                offset = position - source;
+                if (offset < Short.MIN_VALUE || offset > Short.MAX_VALUE) {
+                    /*
+                     * changes the opcode of the jump instruction, in order to
+                     * be able to find it later (see resizeInstructions in
+                     * MethodWriter). These temporary opcodes are similar to
+                     * jump instruction opcodes, except that the 2 bytes offset
+                     * is unsigned (and can therefore represent values from 0 to
+                     * 65535, which is sufficient since the size of a method is
+                     * limited to 65535 bytes).
+                     */
+                    int opcode = data[reference - 1] & 0xFF;
+                    if (opcode <= Opcodes.JSR) {
+                        // changes IFEQ ... JSR to opcodes 202 to 217
+                        data[reference - 1] = (byte) (opcode + 49);
+                    } else {
+                        // changes IFNULL and IFNONNULL to opcodes 218 and 219
+                        data[reference - 1] = (byte) (opcode + 20);
+                    }
+                    needUpdate = true;
+                }
+                data[reference++] = (byte) (offset >>> 8);
+                data[reference] = (byte) offset;
+            } else {
+                offset = position + source + 1;
+                data[reference++] = (byte) (offset >>> 24);
+                data[reference++] = (byte) (offset >>> 16);
+                data[reference++] = (byte) (offset >>> 8);
+                data[reference] = (byte) offset;
+            }
+        }
+        return needUpdate;
+    }
+
+    /**
+     * Returns the first label of the series to which this label belongs. For an
+     * isolated label or for the first label in a series of successive labels,
+     * this method returns the label itself. For other labels it returns the
+     * first label of the series.
+     *
+     * @return the first label of the series to which this label belongs.
+     */
+    Label getFirst() {
+        return frame == null ? this : frame.owner;
+    }
+
+    // ------------------------------------------------------------------------
+    // Methods related to subroutines
+    // ------------------------------------------------------------------------
+
+    /**
+     * Returns true is this basic block belongs to the given subroutine.
+     *
+     * @param id
+     *            a subroutine id.
+     * @return true is this basic block belongs to the given subroutine.
+     */
+    boolean inSubroutine(final long id) {
+        if ((status & Label.VISITED) != 0) {
+            return (srcAndRefPositions[(int) (id >>> 32)] & (int) id) != 0;
+        }
+        return false;
+    }
+
+    /**
+     * Returns true if this basic block and the given one belong to a common
+     * subroutine.
+     *
+     * @param block
+     *            another basic block.
+     * @return true if this basic block and the given one belong to a common
+     *         subroutine.
+     */
+    boolean inSameSubroutine(final Label block) {
+        if ((status & VISITED) == 0 || (block.status & VISITED) == 0) {
+            return false;
+        }
+        for (int i = 0; i < srcAndRefPositions.length; ++i) {
+            if ((srcAndRefPositions[i] & block.srcAndRefPositions[i]) != 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Marks this basic block as belonging to the given subroutine.
+     *
+     * @param id
+     *            a subroutine id.
+     * @param nbSubroutines
+     *            the total number of subroutines in the method.
+     */
+    void addToSubroutine(final long id, final int nbSubroutines) {
+        if ((status & VISITED) == 0) {
+            status |= VISITED;
+            srcAndRefPositions = new int[nbSubroutines / 32 + 1];
+        }
+        srcAndRefPositions[(int) (id >>> 32)] |= (int) id;
+    }
+
+    /**
+     * Finds the basic blocks that belong to a given subroutine, and marks these
+     * blocks as belonging to this subroutine. This method follows the control
+     * flow graph to find all the blocks that are reachable from the current
+     * block WITHOUT following any JSR target.
+     *
+     * @param JSR
+     *            a JSR block that jumps to this subroutine. If this JSR is not
+     *            null it is added to the successor of the RET blocks found in
+     *            the subroutine.
+     * @param id
+     *            the id of this subroutine.
+     * @param nbSubroutines
+     *            the total number of subroutines in the method.
+     */
+    void visitSubroutine(final Label JSR, final long id, final int nbSubroutines) {
+        // user managed stack of labels, to avoid using a recursive method
+        // (recursivity can lead to stack overflow with very large methods)
+        Label stack = this;
+        while (stack != null) {
+            // removes a label l from the stack
+            Label l = stack;
+            stack = l.next;
+            l.next = null;
+
+            if (JSR != null) {
+                if ((l.status & VISITED2) != 0) {
+                    continue;
+                }
+                l.status |= VISITED2;
+                // adds JSR to the successors of l, if it is a RET block
+                if ((l.status & RET) != 0) {
+                    if (!l.inSameSubroutine(JSR)) {
+                        Edge e = new Edge();
+                        e.info = l.inputStackTop;
+                        e.successor = JSR.successors.successor;
+                        e.next = l.successors;
+                        l.successors = e;
+                    }
+                }
+            } else {
+                // if the l block already belongs to subroutine 'id', continue
+                if (l.inSubroutine(id)) {
+                    continue;
+                }
+                // marks the l block as belonging to subroutine 'id'
+                l.addToSubroutine(id, nbSubroutines);
+            }
+            // pushes each successor of l on the stack, except JSR targets
+            Edge e = l.successors;
+            while (e != null) {
+                // if the l block is a JSR block, then 'l.successors.next' leads
+                // to the JSR target (see {@link #visitJumpInsn}) and must
+                // therefore not be followed
+                if ((l.status & Label.JSR) == 0 || e != l.successors.next) {
+                    // pushes e.successor on the stack if it not already added
+                    if (e.successor.next == null) {
+                        e.successor.next = stack;
+                        stack = e.successor;
+                    }
+                }
+                e = e.next;
+            }
+        }
+    }
+
+    // ------------------------------------------------------------------------
+    // Overriden Object methods
+    // ------------------------------------------------------------------------
+
+    /**
+     * Returns a string representation of this label.
+     *
+     * @return a string representation of this label.
+     */
+    @Override
+    public String toString() {
+        return "L" + System.identityHashCode(this);
+    }
+}

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

@@ -3,10 +3,12 @@
  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.redkale.util;
+package org.redkale.asm;
 
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
 import java.util.*;
-import jdk.internal.org.objectweb.asm.*;
+import static org.redkale.asm.Opcodes.*;
 
 /**
  * MethodVisitor 的调试类
@@ -15,13 +17,13 @@ import jdk.internal.org.objectweb.asm.*;
  *
  * @author zhangjx
  */
-public class AsmMethodVisitor {
+public class MethodDebugVisitor {
 
     private final MethodVisitor visitor;
 
     private boolean debug = false;
 
-    public AsmMethodVisitor setDebug(boolean d) {
+    public MethodDebugVisitor setDebug(boolean d) {
         debug = d;
         return this;
     }
@@ -33,7 +35,7 @@ public class AsmMethodVisitor {
         System.out.println();
     }
 
-    private final Map<Label, Integer> labels = new LinkedHashMap();
+    private final Map<Label, Integer> labels = new LinkedHashMap<>();
 
     private static final String[] opcodes = new String[200]; //0 -18
 
@@ -55,11 +57,20 @@ public class AsmMethodVisitor {
         }
     }
 
-    public AsmMethodVisitor(MethodVisitor visitor) {
+    /**
+     *
+     * @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 + ");");
@@ -173,7 +184,7 @@ public class AsmMethodVisitor {
         if (debug) {
             if (o instanceof CharSequence) {
                 System.out.println("mv.visitLdcInsn(\"" + o + "\");");
-            } else if (o instanceof jdk.internal.org.objectweb.asm.Type) {
+            } else if (o instanceof org.redkale.asm.Type) {
                 System.out.println("mv.visitLdcInsn(Type.getType(\"" + o + "\"));");
             } else {
                 System.out.println("mv.visitLdcInsn(" + o + ");");
@@ -190,4 +201,74 @@ public class AsmMethodVisitor {
         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

@@ -0,0 +1,855 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+/**
+ * A visitor to visit a Java method. The methods of this class must be called in
+ * the following order: ( <tt>visitParameter</tt> )* [
+ * <tt>visitAnnotationDefault</tt> ] ( <tt>visitAnnotation</tt> |
+ * <tt>visitParameterAnnotation</tt> <tt>visitTypeAnnotation</tt> |
+ * <tt>visitAttribute</tt> )* [ <tt>visitCode</tt> ( <tt>visitFrame</tt> |
+ * &#60;tt&#62;visit<i>X</i>Insn&#60;/tt&#62; | &#60;tt&#62;visitLabel&#60;/tt&#62; |
+ * &#60;tt&#62;visitInsnAnnotation&#60;/tt&#62; | &#60;tt&#62;visitTryCatchBlock&#60;/tt&#62; |
+ * &#60;tt&#62;visitTryCatchAnnotation&#60;/tt&#62; | &#60;tt&#62;visitLocalVariable&#60;/tt&#62; |
+ * &#60;tt&#62;visitLocalVariableAnnotation&#60;/tt&#62; | &#60;tt&#62;visitLineNumber&#60;/tt&#62; )*
+ * &#60;tt&#62;visitMaxs&#60;/tt&#62; ] &#60;tt&#62;visitEnd&#60;/tt&#62;. In addition, the
+ * &#60;tt&#62;visit<i>X</i>Insn&#60;/tt&#62; and &#60;tt&#62;visitLabel&#60;/tt&#62; methods must be called in
+ * the sequential order of the bytecode instructions of the visited code,
+ * &#60;tt&#62;visitInsnAnnotation&#60;/tt&#62; must be called <i>after</i> the annotated
+ * instruction, &#60;tt&#62;visitTryCatchBlock&#60;/tt&#62; must be called <i>before</i> the
+ * labels passed as arguments have been visited,
+ * &#60;tt&#62;visitTryCatchBlockAnnotation&#60;/tt&#62; must be called <i>after</i> the
+ * corresponding try catch block has been visited, and the
+ * &#60;tt&#62;visitLocalVariable&#60;/tt&#62;, &#60;tt&#62;visitLocalVariableAnnotation&#60;/tt&#62; and
+ * &#60;tt&#62;visitLineNumber&#60;/tt&#62; methods must be called <i>after</i> the labels
+ * passed as arguments have been visited.
+ *
+ * @author Eric Bruneton
+ */
+public abstract class MethodVisitor {
+
+    /**
+     * The ASM API version implemented by this visitor. The value of this field
+     * must be one of {@link Opcodes#ASM4}, {@link Opcodes#ASM5} or {@link Opcodes#ASM6}.
+     */
+    protected final int api;
+
+    /**
+     * The method visitor to which this visitor must delegate method calls. May
+     * be null.
+     */
+    protected MethodVisitor mv;
+
+    /**
+     * Constructs a new {@link MethodVisitor}.
+     *
+     * @param api
+     *            the ASM API version implemented by this visitor. Must be one
+     *            of {@link Opcodes#ASM4}, {@link Opcodes#ASM5} or {@link Opcodes#ASM6}.
+     */
+    public MethodVisitor(final int api) {
+        this(api, null);
+    }
+
+    /**
+     * Constructs a new {@link MethodVisitor}.
+     *
+     * @param api
+     *            the ASM API version implemented by this visitor. Must be one
+     *            of {@link Opcodes#ASM4}, {@link Opcodes#ASM5} or {@link Opcodes#ASM6}.
+     * @param mv
+     *            the method visitor to which this visitor must delegate method
+     *            calls. May be null.
+     */
+    public MethodVisitor(final int api, final MethodVisitor mv) {
+        this.api = api;
+        this.mv = mv;
+    }
+
+    // -------------------------------------------------------------------------
+    // Parameters, annotations and non standard attributes
+    // -------------------------------------------------------------------------
+
+    /**
+     * Visits a parameter of this method.
+     *
+     * @param name
+     *            parameter name or null if none is provided.
+     * @param access
+     *            the parameter's access flags, only &#60;tt&#62;ACC_FINAL&#60;/tt&#62;,
+     *            &#60;tt&#62;ACC_SYNTHETIC&#60;/tt&#62; or/and &#60;tt&#62;ACC_MANDATED&#60;/tt&#62; are
+     *            allowed (see {@link Opcodes}).
+     */
+    public void visitParameter(String name, int access) {
+        if (mv != null) {
+            mv.visitParameter(name, access);
+        }
+    }
+
+    /**
+     * Visits the default value of this annotation interface method.
+     *
+     * @return a visitor to the visit the actual default value of this
+     *         annotation interface method, or &#60;tt&#62;null&#60;/tt&#62; if this visitor is
+     *         not interested in visiting this default value. The 'name'
+     *         parameters passed to the methods of this annotation visitor are
+     *         ignored. Moreover, exacly one visit method must be called on this
+     *         annotation visitor, followed by visitEnd.
+     */
+    public AnnotationVisitor visitAnnotationDefault() {
+        if (mv != null) {
+            return mv.visitAnnotationDefault();
+        }
+        return null;
+    }
+
+    /**
+     * Visits an annotation of this method.
+     *
+     * @param desc
+     *            the class descriptor of the annotation class.
+     * @param visible
+     *            &#60;tt&#62;true&#60;/tt&#62; if the annotation is visible at runtime.
+     * @return a visitor to visit the annotation values, or &#60;tt&#62;null&#60;/tt&#62; if
+     *         this visitor is not interested in visiting this annotation.
+     */
+    public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+        if (mv != null) {
+            return mv.visitAnnotation(desc, visible);
+        }
+        return null;
+    }
+
+    /**
+     * Visits an annotation on a type in the method signature.
+     *
+     * @param typeRef
+     *            a reference to the annotated type. The sort of this type
+     *            reference must be {@link TypeReference#METHOD_TYPE_PARAMETER
+     *            METHOD_TYPE_PARAMETER},
+     *            {@link TypeReference#METHOD_TYPE_PARAMETER_BOUND
+     *            METHOD_TYPE_PARAMETER_BOUND},
+     *            {@link TypeReference#METHOD_RETURN METHOD_RETURN},
+     *            {@link TypeReference#METHOD_RECEIVER METHOD_RECEIVER},
+     *            {@link TypeReference#METHOD_FORMAL_PARAMETER
+     *            METHOD_FORMAL_PARAMETER} or {@link TypeReference#THROWS
+     *            THROWS}. See {@link TypeReference}.
+     * @param typePath
+     *            the path to the annotated type argument, wildcard bound, array
+     *            element type, or static inner type within 'typeRef'. May be
+     *            &#60;tt&#62;null&#60;/tt&#62; if the annotation targets 'typeRef' as a whole.
+     * @param desc
+     *            the class descriptor of the annotation class.
+     * @param visible
+     *            &#60;tt&#62;true&#60;/tt&#62; if the annotation is visible at runtime.
+     * @return a visitor to visit the annotation values, or &#60;tt&#62;null&#60;/tt&#62; if
+     *         this visitor is not interested in visiting this annotation.
+     */
+    public AnnotationVisitor visitTypeAnnotation(int typeRef,
+            TypePath typePath, String desc, boolean visible) {
+        if (mv != null) {
+            return mv.visitTypeAnnotation(typeRef, typePath, desc, visible);
+        }
+        return null;
+    }
+
+    /**
+     * Visits an annotation of a parameter this method.
+     *
+     * @param parameter
+     *            the parameter index.
+     * @param desc
+     *            the class descriptor of the annotation class.
+     * @param visible
+     *            &#60;tt&#62;true&#60;/tt&#62; if the annotation is visible at runtime.
+     * @return a visitor to visit the annotation values, or &#60;tt&#62;null&#60;/tt&#62; if
+     *         this visitor is not interested in visiting this annotation.
+     */
+    public AnnotationVisitor visitParameterAnnotation(int parameter,
+            String desc, boolean visible) {
+        if (mv != null) {
+            return mv.visitParameterAnnotation(parameter, desc, visible);
+        }
+        return null;
+    }
+
+    /**
+     * Visits a non standard attribute of this method.
+     *
+     * @param attr
+     *            an attribute.
+     */
+    public void visitAttribute(Attribute attr) {
+        if (mv != null) {
+            mv.visitAttribute(attr);
+        }
+    }
+
+    /**
+     * Starts the visit of the method's code, if any (i.e. non abstract method).
+     */
+    public void visitCode() {
+        if (mv != null) {
+            mv.visitCode();
+        }
+    }
+
+    /**
+     * Visits the current state of the local variables and operand stack
+     * elements. This method must(*) be called <i>just before</i> any
+     * instruction <b>i</b> that follows an unconditional branch instruction
+     * such as GOTO or THROW, that is the target of a jump instruction, or that
+     * starts an exception handler block. The visited types must describe the
+     * values of the local variables and of the operand stack elements <i>just
+     * before</i> <b>i</b> is executed.<br>
+     * <br>
+     * (*) this is mandatory only for classes whose version is greater than or
+     * equal to {@link Opcodes#V1_6 V1_6}. <br>
+     * <br>
+     * The frames of a method must be given either in expanded form, or in
+     * compressed form (all frames must use the same format, i.e. you must not
+     * mix expanded and compressed frames within a single method):
+     * <ul>
+     * <li>In expanded form, all frames must have the F_NEW type.</li>
+     * <li>In compressed form, frames are basically "deltas" from the state of
+     * the previous frame:
+     * <ul>
+     * <li>{@link Opcodes#F_SAME} representing frame with exactly the same
+     * locals as the previous frame and with the empty stack.</li>
+     * <li>{@link Opcodes#F_SAME1} representing frame with exactly the same
+     * locals as the previous frame and with single value on the stack (
+     * <code>nStack</code> is 1 and <code>stack[0]</code> contains value for the
+     * type of the stack item).</li>
+     * <li>{@link Opcodes#F_APPEND} representing frame with current locals are
+     * the same as the locals in the previous frame, except that additional
+     * locals are defined (<code>nLocal</code> is 1, 2 or 3 and
+     * <code>local</code> elements contains values representing added types).</li>
+     * <li>{@link Opcodes#F_CHOP} representing frame with current locals are the
+     * same as the locals in the previous frame, except that the last 1-3 locals
+     * are absent and with the empty stack (<code>nLocals</code> is 1, 2 or 3).</li>
+     * <li>{@link Opcodes#F_FULL} representing complete frame data.</li>
+     * </ul>
+     * </li>
+     * </ul>
+     * <br>
+     * In both cases the first frame, corresponding to the method's parameters
+     * and access flags, is implicit and must not be visited. Also, it is
+     * illegal to visit two or more frames for the same code location (i.e., at
+     * least one instruction must be visited between two calls to visitFrame).
+     *
+     * @param type
+     *            the type of this stack map frame. Must be
+     *            {@link Opcodes#F_NEW} for expanded frames, or
+     *            {@link Opcodes#F_FULL}, {@link Opcodes#F_APPEND},
+     *            {@link Opcodes#F_CHOP}, {@link Opcodes#F_SAME} or
+     *            {@link Opcodes#F_APPEND}, {@link Opcodes#F_SAME1} for
+     *            compressed frames.
+     * @param nLocal
+     *            the number of local variables in the visited frame.
+     * @param local
+     *            the local variable types in this frame. This array must not be
+     *            modified. Primitive types are represented by
+     *            {@link Opcodes#TOP}, {@link Opcodes#INTEGER},
+     *            {@link Opcodes#FLOAT}, {@link Opcodes#LONG},
+     *            {@link Opcodes#DOUBLE},{@link Opcodes#NULL} or
+     *            {@link Opcodes#UNINITIALIZED_THIS} (long and double are
+     *            represented by a single element). Reference types are
+     *            represented by String objects (representing internal names),
+     *            and uninitialized types by Label objects (this label
+     *            designates the NEW instruction that created this uninitialized
+     *            value).
+     * @param nStack
+     *            the number of operand stack elements in the visited frame.
+     * @param stack
+     *            the operand stack types in this frame. This array must not be
+     *            modified. Its content has the same format as the "local"
+     *            array.
+     * @throws IllegalStateException
+     *             if a frame is visited just after another one, without any
+     *             instruction between the two (unless this frame is a
+     *             Opcodes#F_SAME frame, in which case it is silently ignored).
+     */
+    public void visitFrame(int type, int nLocal, Object[] local, int nStack,
+            Object[] stack) {
+        if (mv != null) {
+            mv.visitFrame(type, nLocal, local, nStack, stack);
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Normal instructions
+    // -------------------------------------------------------------------------
+
+    /**
+     * Visits a zero operand instruction.
+     *
+     * @param opcode
+     *            the opcode of the instruction to be visited. This opcode is
+     *            either NOP, ACONST_NULL, ICONST_M1, ICONST_0, ICONST_1,
+     *            ICONST_2, ICONST_3, ICONST_4, ICONST_5, LCONST_0, LCONST_1,
+     *            FCONST_0, FCONST_1, FCONST_2, DCONST_0, DCONST_1, IALOAD,
+     *            LALOAD, FALOAD, DALOAD, AALOAD, BALOAD, CALOAD, SALOAD,
+     *            IASTORE, LASTORE, FASTORE, DASTORE, AASTORE, BASTORE, CASTORE,
+     *            SASTORE, POP, POP2, DUP, DUP_X1, DUP_X2, DUP2, DUP2_X1,
+     *            DUP2_X2, SWAP, IADD, LADD, FADD, DADD, ISUB, LSUB, FSUB, DSUB,
+     *            IMUL, LMUL, FMUL, DMUL, IDIV, LDIV, FDIV, DDIV, IREM, LREM,
+     *            FREM, DREM, INEG, LNEG, FNEG, DNEG, ISHL, LSHL, ISHR, LSHR,
+     *            IUSHR, LUSHR, IAND, LAND, IOR, LOR, IXOR, LXOR, I2L, I2F, I2D,
+     *            L2I, L2F, L2D, F2I, F2L, F2D, D2I, D2L, D2F, I2B, I2C, I2S,
+     *            LCMP, FCMPL, FCMPG, DCMPL, DCMPG, IRETURN, LRETURN, FRETURN,
+     *            DRETURN, ARETURN, RETURN, ARRAYLENGTH, ATHROW, MONITORENTER,
+     *            or MONITOREXIT.
+     */
+    public void visitInsn(int opcode) {
+        if (mv != null) {
+            mv.visitInsn(opcode);
+        }
+    }
+
+    /**
+     * Visits an instruction with a single int operand.
+     *
+     * @param opcode
+     *            the opcode of the instruction to be visited. This opcode is
+     *            either BIPUSH, SIPUSH or NEWARRAY.
+     * @param operand
+     *            the operand of the instruction to be visited.<br>
+     *            When opcode is BIPUSH, operand value should be between
+     *            Byte.MIN_VALUE and Byte.MAX_VALUE.<br>
+     *            When opcode is SIPUSH, operand value should be between
+     *            Short.MIN_VALUE and Short.MAX_VALUE.<br>
+     *            When opcode is NEWARRAY, operand value should be one of
+     *            {@link Opcodes#T_BOOLEAN}, {@link Opcodes#T_CHAR},
+     *            {@link Opcodes#T_FLOAT}, {@link Opcodes#T_DOUBLE},
+     *            {@link Opcodes#T_BYTE}, {@link Opcodes#T_SHORT},
+     *            {@link Opcodes#T_INT} or {@link Opcodes#T_LONG}.
+     */
+    public void visitIntInsn(int opcode, int operand) {
+        if (mv != null) {
+            mv.visitIntInsn(opcode, operand);
+        }
+    }
+
+    /**
+     * Visits a local variable instruction. A local variable instruction is an
+     * instruction that loads or stores the value of a local variable.
+     *
+     * @param opcode
+     *            the opcode of the local variable instruction to be visited.
+     *            This opcode is either ILOAD, LLOAD, FLOAD, DLOAD, ALOAD,
+     *            ISTORE, LSTORE, FSTORE, DSTORE, ASTORE or RET.
+     * @param var
+     *            the operand of the instruction to be visited. This operand is
+     *            the index of a local variable.
+     */
+    public void visitVarInsn(int opcode, int var) {
+        if (mv != null) {
+            mv.visitVarInsn(opcode, var);
+        }
+    }
+
+    /**
+     * Visits a type instruction. A type instruction is an instruction that
+     * takes the internal name of a class as parameter.
+     *
+     * @param opcode
+     *            the opcode of the type instruction to be visited. This opcode
+     *            is either NEW, ANEWARRAY, CHECKCAST or INSTANCEOF.
+     * @param type
+     *            the operand of the instruction to be visited. This operand
+     *            must be the internal name of an object or array class (see
+     *            {@link Type#getInternalName() getInternalName}).
+     */
+    public void visitTypeInsn(int opcode, String type) {
+        if (mv != null) {
+            mv.visitTypeInsn(opcode, type);
+        }
+    }
+
+    /**
+     * Visits a field instruction. A field instruction is an instruction that
+     * loads or stores the value of a field of an object.
+     *
+     * @param opcode
+     *            the opcode of the type instruction to be visited. This opcode
+     *            is either GETSTATIC, PUTSTATIC, GETFIELD or PUTFIELD.
+     * @param owner
+     *            the internal name of the field's owner class (see
+     *            {@link Type#getInternalName() getInternalName}).
+     * @param name
+     *            the field's name.
+     * @param desc
+     *            the field's descriptor (see {@link Type Type}).
+     */
+    public void visitFieldInsn(int opcode, String owner, String name,
+            String desc) {
+        if (mv != null) {
+            mv.visitFieldInsn(opcode, owner, name, desc);
+        }
+    }
+
+    /**
+     * 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}).
+     * @param itf
+     *            if the method's owner class is an interface.
+     */
+    public void visitMethodInsn(int opcode, String owner, String name,
+            String desc, boolean itf) {
+        if (mv != null) {
+            mv.visitMethodInsn(opcode, owner, name, desc, itf);
+        }
+    }
+
+    /**
+     * Visits an invokedynamic instruction.
+     *
+     * @param name
+     *            the method's name.
+     * @param desc
+     *            the method's descriptor (see {@link Type Type}).
+     * @param bsm
+     *            the bootstrap method.
+     * @param bsmArgs
+     *            the bootstrap method constant arguments. Each argument must be
+     *            an {@link Integer}, {@link Float}, {@link Long},
+     *            {@link Double}, {@link String}, {@link Type} or {@link Handle}
+     *            value. This method is allowed to modify the content of the
+     *            array so a caller should expect that this array may change.
+     */
+    public void visitInvokeDynamicInsn(String name, String desc, Handle bsm,
+            Object... bsmArgs) {
+        if (mv != null) {
+            mv.visitInvokeDynamicInsn(name, desc, bsm, bsmArgs);
+        }
+    }
+
+    /**
+     * Visits a jump instruction. A jump instruction is an instruction that may
+     * jump to another instruction.
+     *
+     * @param opcode
+     *            the opcode of the type instruction to be visited. This opcode
+     *            is either IFEQ, IFNE, IFLT, IFGE, IFGT, IFLE, IF_ICMPEQ,
+     *            IF_ICMPNE, IF_ICMPLT, IF_ICMPGE, IF_ICMPGT, IF_ICMPLE,
+     *            IF_ACMPEQ, IF_ACMPNE, GOTO, JSR, IFNULL or IFNONNULL.
+     * @param label
+     *            the operand of the instruction to be visited. This operand is
+     *            a label that designates the instruction to which the jump
+     *            instruction may jump.
+     */
+    public void visitJumpInsn(int opcode, Label label) {
+        if (mv != null) {
+            mv.visitJumpInsn(opcode, label);
+        }
+    }
+
+    /**
+     * Visits a label. A label designates the instruction that will be visited
+     * just after it.
+     *
+     * @param label
+     *            a {@link Label Label} object.
+     */
+    public void visitLabel(Label label) {
+        if (mv != null) {
+            mv.visitLabel(label);
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Special instructions
+    // -------------------------------------------------------------------------
+
+    /**
+     * Visits a LDC instruction. Note that new constant types may be added in
+     * future versions of the Java Virtual Machine. To easily detect new
+     * constant types, implementations of this method should check for
+     * unexpected constant types, like this:
+     *
+     * <pre>
+     * if (cst instanceof Integer) {
+     *     // ...
+     * } else if (cst instanceof Float) {
+     *     // ...
+     * } else if (cst instanceof Long) {
+     *     // ...
+     * } else if (cst instanceof Double) {
+     *     // ...
+     * } else if (cst instanceof String) {
+     *     // ...
+     * } else if (cst instanceof Type) {
+     *     int sort = ((Type) cst).getSort();
+     *     if (sort == Type.OBJECT) {
+     *         // ...
+     *     } else if (sort == Type.ARRAY) {
+     *         // ...
+     *     } else if (sort == Type.METHOD) {
+     *         // ...
+     *     } else {
+     *         // throw an exception
+     *     }
+     * } else if (cst instanceof Handle) {
+     *     // ...
+     * } else {
+     *     // throw an exception
+     * }
+     * </pre>
+     *
+     * @param cst
+     *            the constant to be loaded on the stack. This parameter must be
+     *            a non null {@link Integer}, a {@link Float}, a {@link Long}, a
+     *            {@link Double}, a {@link String}, a {@link Type} of OBJECT or
+     *            ARRAY sort for &#60;tt&#62;.class&#60;/tt&#62; constants, for classes whose
+     *            version is 49.0, a {@link Type} of METHOD sort or a
+     *            {@link Handle} for MethodType and MethodHandle constants, for
+     *            classes whose version is 51.0.
+     */
+    public void visitLdcInsn(Object cst) {
+        if (mv != null) {
+            mv.visitLdcInsn(cst);
+        }
+    }
+
+    /**
+     * Visits an IINC instruction.
+     *
+     * @param var
+     *            index of the local variable to be incremented.
+     * @param increment
+     *            amount to increment the local variable by.
+     */
+    public void visitIincInsn(int var, int increment) {
+        if (mv != null) {
+            mv.visitIincInsn(var, increment);
+        }
+    }
+
+    /**
+     * Visits a TABLESWITCH instruction.
+     *
+     * @param min
+     *            the minimum key value.
+     * @param max
+     *            the maximum key value.
+     * @param dflt
+     *            beginning of the default handler block.
+     * @param labels
+     *            beginnings of the handler blocks. &#60;tt&#62;labels[i]&#60;/tt&#62; is the
+     *            beginning of the handler block for the &#60;tt&#62;min + i&#60;/tt&#62; key.
+     */
+    public void visitTableSwitchInsn(int min, int max, Label dflt,
+            Label... labels) {
+        if (mv != null) {
+            mv.visitTableSwitchInsn(min, max, dflt, labels);
+        }
+    }
+
+    /**
+     * Visits a LOOKUPSWITCH instruction.
+     *
+     * @param dflt
+     *            beginning of the default handler block.
+     * @param keys
+     *            the values of the keys.
+     * @param labels
+     *            beginnings of the handler blocks. &#60;tt&#62;labels[i]&#60;/tt&#62; is the
+     *            beginning of the handler block for the &#60;tt&#62;keys[i]&#60;/tt&#62; key.
+     */
+    public void visitLookupSwitchInsn(Label dflt, int[] keys, Label[] labels) {
+        if (mv != null) {
+            mv.visitLookupSwitchInsn(dflt, keys, labels);
+        }
+    }
+
+    /**
+     * Visits a MULTIANEWARRAY instruction.
+     *
+     * @param desc
+     *            an array type descriptor (see {@link Type Type}).
+     * @param dims
+     *            number of dimensions of the array to allocate.
+     */
+    public void visitMultiANewArrayInsn(String desc, int dims) {
+        if (mv != null) {
+            mv.visitMultiANewArrayInsn(desc, dims);
+        }
+    }
+
+    /**
+     * Visits an annotation on an instruction. This method must be called just
+     * <i>after</i> the annotated instruction. It can be called several times
+     * for the same instruction.
+     *
+     * @param typeRef
+     *            a reference to the annotated type. The sort of this type
+     *            reference must be {@link TypeReference#INSTANCEOF INSTANCEOF},
+     *            {@link TypeReference#NEW NEW},
+     *            {@link TypeReference#CONSTRUCTOR_REFERENCE
+     *            CONSTRUCTOR_REFERENCE}, {@link TypeReference#METHOD_REFERENCE
+     *            METHOD_REFERENCE}, {@link TypeReference#CAST CAST},
+     *            {@link TypeReference#CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT
+     *            CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT},
+     *            {@link TypeReference#METHOD_INVOCATION_TYPE_ARGUMENT
+     *            METHOD_INVOCATION_TYPE_ARGUMENT},
+     *            {@link TypeReference#CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT
+     *            CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT}, or
+     *            {@link TypeReference#METHOD_REFERENCE_TYPE_ARGUMENT
+     *            METHOD_REFERENCE_TYPE_ARGUMENT}. See {@link TypeReference}.
+     * @param typePath
+     *            the path to the annotated type argument, wildcard bound, array
+     *            element type, or static inner type within 'typeRef'. May be
+     *            &#60;tt&#62;null&#60;/tt&#62; if the annotation targets 'typeRef' as a whole.
+     * @param desc
+     *            the class descriptor of the annotation class.
+     * @param visible
+     *            &#60;tt&#62;true&#60;/tt&#62; if the annotation is visible at runtime.
+     * @return a visitor to visit the annotation values, or &#60;tt&#62;null&#60;/tt&#62; if
+     *         this visitor is not interested in visiting this annotation.
+     */
+    public AnnotationVisitor visitInsnAnnotation(int typeRef,
+            TypePath typePath, String desc, boolean visible) {
+        if (mv != null) {
+            return mv.visitInsnAnnotation(typeRef, typePath, desc, visible);
+        }
+        return null;
+    }
+
+    // -------------------------------------------------------------------------
+    // Exceptions table entries, debug information, max stack and max locals
+    // -------------------------------------------------------------------------
+
+    /**
+     * Visits a try catch block.
+     *
+     * @param start
+     *            beginning of the exception handler's scope (inclusive).
+     * @param end
+     *            end of the exception handler's scope (exclusive).
+     * @param handler
+     *            beginning of the exception handler's code.
+     * @param type
+     *            internal name of the type of exceptions handled by the
+     *            handler, or &#60;tt&#62;null&#60;/tt&#62; to catch any exceptions (for
+     *            "finally" blocks).
+     * @throws IllegalArgumentException
+     *             if one of the labels has already been visited by this visitor
+     *             (by the {@link #visitLabel visitLabel} method).
+     */
+    public void visitTryCatchBlock(Label start, Label end, Label handler,
+            String type) {
+        if (mv != null) {
+            mv.visitTryCatchBlock(start, end, handler, type);
+        }
+    }
+
+    /**
+     * Visits an annotation on an exception handler type. This method must be
+     * called <i>after</i> the {@link #visitTryCatchBlock} for the annotated
+     * exception handler. It can be called several times for the same exception
+     * handler.
+     *
+     * @param typeRef
+     *            a reference to the annotated type. The sort of this type
+     *            reference must be {@link TypeReference#EXCEPTION_PARAMETER
+     *            EXCEPTION_PARAMETER}. See {@link TypeReference}.
+     * @param typePath
+     *            the path to the annotated type argument, wildcard bound, array
+     *            element type, or static inner type within 'typeRef'. May be
+     *            &#60;tt&#62;null&#60;/tt&#62; if the annotation targets 'typeRef' as a whole.
+     * @param desc
+     *            the class descriptor of the annotation class.
+     * @param visible
+     *            &#60;tt&#62;true&#60;/tt&#62; if the annotation is visible at runtime.
+     * @return a visitor to visit the annotation values, or &#60;tt&#62;null&#60;/tt&#62; if
+     *         this visitor is not interested in visiting this annotation.
+     */
+    public AnnotationVisitor visitTryCatchAnnotation(int typeRef,
+            TypePath typePath, String desc, boolean visible) {
+        if (mv != null) {
+            return mv.visitTryCatchAnnotation(typeRef, typePath, desc, visible);
+        }
+        return null;
+    }
+
+    /**
+     * Visits a local variable declaration.
+     *
+     * @param name
+     *            the name of a local variable.
+     * @param desc
+     *            the type descriptor of this local variable.
+     * @param signature
+     *            the type signature of this local variable. May be
+     *            &#60;tt&#62;null&#60;/tt&#62; if the local variable type does not use generic
+     *            types.
+     * @param start
+     *            the first instruction corresponding to the scope of this local
+     *            variable (inclusive).
+     * @param end
+     *            the last instruction corresponding to the scope of this local
+     *            variable (exclusive).
+     * @param index
+     *            the local variable's index.
+     * @throws IllegalArgumentException
+     *             if one of the labels has not already been visited by this
+     *             visitor (by the {@link #visitLabel visitLabel} method).
+     */
+    public void visitLocalVariable(String name, String desc, String signature,
+            Label start, Label end, int index) {
+        if (mv != null) {
+            mv.visitLocalVariable(name, desc, signature, start, end, index);
+        }
+    }
+
+    /**
+     * Visits an annotation on a local variable type.
+     *
+     * @param typeRef
+     *            a reference to the annotated type. The sort of this type
+     *            reference must be {@link TypeReference#LOCAL_VARIABLE
+     *            LOCAL_VARIABLE} or {@link TypeReference#RESOURCE_VARIABLE
+     *            RESOURCE_VARIABLE}. See {@link TypeReference}.
+     * @param typePath
+     *            the path to the annotated type argument, wildcard bound, array
+     *            element type, or static inner type within 'typeRef'. May be
+     *            &#60;tt&#62;null&#60;/tt&#62; if the annotation targets 'typeRef' as a whole.
+     * @param start
+     *            the fist instructions corresponding to the continuous ranges
+     *            that make the scope of this local variable (inclusive).
+     * @param end
+     *            the last instructions corresponding to the continuous ranges
+     *            that make the scope of this local variable (exclusive). This
+     *            array must have the same size as the 'start' array.
+     * @param index
+     *            the local variable's index in each range. This array must have
+     *            the same size as the 'start' array.
+     * @param desc
+     *            the class descriptor of the annotation class.
+     * @param visible
+     *            &#60;tt&#62;true&#60;/tt&#62; if the annotation is visible at runtime.
+     * @return a visitor to visit the annotation values, or &#60;tt&#62;null&#60;/tt&#62; if
+     *         this visitor is not interested in visiting this annotation.
+     */
+    public AnnotationVisitor visitLocalVariableAnnotation(int typeRef,
+            TypePath typePath, Label[] start, Label[] end, int[] index,
+            String desc, boolean visible) {
+        if (mv != null) {
+            return mv.visitLocalVariableAnnotation(typeRef, typePath, start,
+                    end, index, desc, visible);
+        }
+        return null;
+    }
+
+    /**
+     * Visits a line number declaration.
+     *
+     * @param line
+     *            a line number. This number refers to the source file from
+     *            which the class was compiled.
+     * @param start
+     *            the first instruction corresponding to this line number.
+     * @throws IllegalArgumentException
+     *             if &#60;tt&#62;start&#60;/tt&#62; has not already been visited by this
+     *             visitor (by the {@link #visitLabel visitLabel} method).
+     */
+    public void visitLineNumber(int line, Label start) {
+        if (mv != null) {
+            mv.visitLineNumber(line, start);
+        }
+    }
+
+    /**
+     * Visits the maximum stack size and the maximum number of local variables
+     * of the method.
+     *
+     * @param maxStack
+     *            maximum stack size of the method.
+     * @param maxLocals
+     *            maximum number of local variables for the method.
+     */
+    public void visitMaxs(int maxStack, int maxLocals) {
+        if (mv != null) {
+            mv.visitMaxs(maxStack, maxLocals);
+        }
+    }
+
+    /**
+     * Visits the end of the method. This method, which is the last one to be
+     * called, is used to inform the visitor that all the annotations and
+     * attributes of the method have been visited.
+     */
+    public void visitEnd() {
+        if (mv != null) {
+            mv.visitEnd();
+        }
+    }
+}

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

@@ -0,0 +1,219 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+/**
+ * A visitor to visit a Java module. The methods of this class must be called in
+ * the following order: <tt>visitMainClass</tt> | ( <tt>visitPackage</tt> |
+ * <tt>visitRequire</tt> | <tt>visitExport</tt> | <tt>visitOpen</tt> |
+ * <tt>visitUse</tt> | <tt>visitProvide</tt> )* <tt>visitEnd</tt>.
+ *
+ * The methods {@link #visitRequire(String, int, String)}, {@link #visitExport(String, int, String...)},
+ * {@link #visitOpen(String, int, String...)} and {@link #visitPackage(String)}
+ * take as parameter a package name or a module name. Unlike the other names which are internal names
+ * (names separated by slash), module and package names are qualified names (names separated by dot).
+ *
+ * @author Remi Forax
+ */
+public abstract class ModuleVisitor {
+    /**
+     * The ASM API version implemented by this visitor. The value of this field
+     * must be {@link Opcodes#ASM6}.
+     */
+    protected final int api;
+
+    /**
+     * The module visitor to which this visitor must delegate method calls. May
+     * be null.
+     */
+    protected ModuleVisitor mv;
+
+    /**
+     * Constructs a new {@link ModuleVisitor}.
+     *
+     * @param api
+     *            the ASM API version implemented by this visitor. Must be {@link Opcodes#ASM6}.
+     */
+    public ModuleVisitor(final int api) {
+        this(api, null);
+    }
+
+    /**
+     * Constructs a new {@link ModuleVisitor}.
+     *
+     * @param api
+     *            the ASM API version implemented by this visitor. Must be {@link Opcodes#ASM6}.
+     * @param mv
+     *            the module visitor to which this visitor must delegate method
+     *            calls. May be null.
+     */
+    public ModuleVisitor(final int api, final ModuleVisitor mv) {
+        if (api != Opcodes.ASM6) {
+            throw new IllegalArgumentException();
+        }
+        this.api = api;
+        this.mv = mv;
+    }
+
+    /**
+     * Visit the main class of the current module.
+     *
+     * @param mainClass the internal name of the main class of the current module.
+     */
+    public void visitMainClass(String mainClass) {
+        if (mv != null) {
+            mv.visitMainClass(mainClass);
+        }
+    }
+
+    /**
+     * Visit a package of the current module.
+     *
+     * @param packaze the qualified name of a package.
+     */
+    public void visitPackage(String packaze) {
+        if (mv != null) {
+            mv.visitPackage(packaze);
+        }
+    }
+
+    /**
+     * Visits a dependence of the current module.
+     *
+     * @param module the qualified name of the dependence.
+     * @param access the access flag of the dependence among
+     *        ACC_TRANSITIVE, ACC_STATIC_PHASE, ACC_SYNTHETIC
+     *        and ACC_MANDATED.
+     * @param version the module version at compile time or null.
+     */
+    public void visitRequire(String module, int access, String version) {
+        if (mv != null) {
+            mv.visitRequire(module, access, version);
+        }
+    }
+
+    /**
+     * Visit an exported package of the current module.
+     *
+     * @param packaze the qualified name of the exported package.
+     * @param access the access flag of the exported package,
+     *        valid values are among {@code ACC_SYNTHETIC} and
+     *        {@code ACC_MANDATED}.
+     * @param modules the qualified names of the modules that can access to
+     *        the public classes of the exported package or
+     *        <tt>null</tt>.
+     */
+    public void visitExport(String packaze, int access, String... modules) {
+        if (mv != null) {
+            mv.visitExport(packaze, access, modules);
+        }
+    }
+
+    /**
+     * Visit an open package of the current module.
+     *
+     * @param packaze the qualified name of the opened package.
+     * @param access the access flag of the opened package,
+     *        valid values are among {@code ACC_SYNTHETIC} and
+     *        {@code ACC_MANDATED}.
+     * @param modules the qualified names of the modules that can use deep
+     *        reflection to the classes of the open package or
+     *        <tt>null</tt>.
+     */
+    public void visitOpen(String packaze, int access, String... modules) {
+        if (mv != null) {
+            mv.visitOpen(packaze, access, modules);
+        }
+    }
+
+    /**
+     * Visit a service used by the current module.
+     * The name must be the internal name of an interface or a class.
+     *
+     * @param service the internal name of the service.
+     */
+    public void visitUse(String service) {
+        if (mv != null) {
+            mv.visitUse(service);
+        }
+    }
+
+    /**
+     * Visit an implementation of a service.
+     *
+     * @param service the internal name of the service
+     * @param providers the internal names of the implementations
+     *        of the service (there is at least one provider).
+     */
+    public void visitProvide(String service, String... providers) {
+        if (mv != null) {
+            mv.visitProvide(service, providers);
+        }
+    }
+
+    /**
+     * Visits the end of the module. This method, which is the last one to be
+     * called, is used to inform the visitor that everything have been visited.
+     */
+    public void visitEnd() {
+        if (mv != null) {
+            mv.visitEnd();
+        }
+    }
+}

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

@@ -0,0 +1,322 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.redkale.asm;
+
+/**
+ * @author Remi Forax
+ */
+final class ModuleWriter extends ModuleVisitor {
+    /**
+     * The class writer to which this Module attribute must be added.
+     */
+    private final ClassWriter cw;
+
+    /**
+     * size in byte of the Module attribute.
+     */
+    int size;
+
+    /**
+     * Number of attributes associated with the current module
+     * (Version, ConcealPackages, etc)
+     */
+    int attributeCount;
+
+    /**
+     * Size in bytes of the attributes associated with the current module
+     */
+    int attributesSize;
+
+    /**
+     * module name index in the constant pool
+     */
+    private final int name;
+
+    /**
+     * module access flags
+     */
+    private final int access;
+
+    /**
+     * module version index in the constant pool or 0
+     */
+    private final int version;
+
+    /**
+     * module main class index in the constant pool or 0
+     */
+    private int mainClass;
+
+    /**
+     * number of packages
+     */
+    private int packageCount;
+
+    /**
+     * The packages in bytecode form. This byte vector only contains
+     * the items themselves, the number of items is store in packageCount
+     */
+    private ByteVector packages;
+
+    /**
+     * number of requires items
+     */
+    private int requireCount;
+
+    /**
+     * The requires items in bytecode form. This byte vector only contains
+     * the items themselves, the number of items is store in requireCount
+     */
+    private ByteVector requires;
+
+    /**
+     * number of exports items
+     */
+    private int exportCount;
+
+    /**
+     * The exports items in bytecode form. This byte vector only contains
+     * the items themselves, the number of items is store in exportCount
+     */
+    private ByteVector exports;
+
+    /**
+     * number of opens items
+     */
+    private int openCount;
+
+    /**
+     * The opens items in bytecode form. This byte vector only contains
+     * the items themselves, the number of items is store in openCount
+     */
+    private ByteVector opens;
+
+    /**
+     * number of uses items
+     */
+    private int useCount;
+
+    /**
+     * The uses items in bytecode form. This byte vector only contains
+     * the items themselves, the number of items is store in useCount
+     */
+    private ByteVector uses;
+
+    /**
+     * number of provides items
+     */
+    private int provideCount;
+
+    /**
+     * The uses provides in bytecode form. This byte vector only contains
+     * the items themselves, the number of items is store in provideCount
+     */
+    private ByteVector provides;
+
+    ModuleWriter(final ClassWriter cw, final int name,
+            final int access, final int version) {
+        super(Opcodes.ASM6);
+        this.cw = cw;
+        this.size = 16;  // name + access + version + 5 counts
+        this.name = name;
+        this.access = access;
+        this.version = version;
+    }
+
+    @Override
+    public void visitMainClass(String mainClass) {
+        if (this.mainClass == 0) { // protect against several calls to visitMainClass
+            cw.newUTF8("ModuleMainClass");
+            attributeCount++;
+            attributesSize += 8;
+        }
+        this.mainClass = cw.newClass(mainClass);
+    }
+
+    @Override
+    public void visitPackage(String packaze) {
+        if (packages == null) {
+            // protect against several calls to visitPackage
+            cw.newUTF8("ModulePackages");
+            packages = new ByteVector();
+            attributeCount++;
+            attributesSize += 8;
+        }
+        packages.putShort(cw.newPackage(packaze));
+        packageCount++;
+        attributesSize += 2;
+    }
+
+    @Override
+    public void visitRequire(String module, int access, String version) {
+        if (requires == null) {
+            requires = new ByteVector();
+        }
+        requires.putShort(cw.newModule(module))
+                .putShort(access)
+                .putShort(version == null? 0: cw.newUTF8(version));
+        requireCount++;
+        size += 6;
+    }
+
+    @Override
+    public void visitExport(String packaze, int access, String... modules) {
+        if (exports == null) {
+            exports = new ByteVector();
+        }
+        exports.putShort(cw.newPackage(packaze)).putShort(access);
+        if (modules == null) {
+            exports.putShort(0);
+            size += 6;
+        } else {
+            exports.putShort(modules.length);
+            for(String module: modules) {
+                exports.putShort(cw.newModule(module));
+            }
+            size += 6 + 2 * modules.length;
+        }
+        exportCount++;
+    }
+
+    @Override
+    public void visitOpen(String packaze, int access, String... modules) {
+        if (opens == null) {
+            opens = new ByteVector();
+        }
+        opens.putShort(cw.newPackage(packaze)).putShort(access);
+        if (modules == null) {
+            opens.putShort(0);
+            size += 6;
+        } else {
+            opens.putShort(modules.length);
+            for(String module: modules) {
+                opens.putShort(cw.newModule(module));
+            }
+            size += 6 + 2 * modules.length;
+        }
+        openCount++;
+    }
+
+    @Override
+    public void visitUse(String service) {
+        if (uses == null) {
+            uses = new ByteVector();
+        }
+        uses.putShort(cw.newClass(service));
+        useCount++;
+        size += 2;
+    }
+
+    @Override
+    public void visitProvide(String service, String... providers) {
+        if (provides == null) {
+            provides = new ByteVector();
+        }
+        provides.putShort(cw.newClass(service));
+        provides.putShort(providers.length);
+        for(String provider: providers) {
+            provides.putShort(cw.newClass(provider));
+        }
+        provideCount++;
+        size += 4 + 2 * providers.length;
+    }
+
+    @Override
+    public void visitEnd() {
+        // empty
+    }
+
+    void putAttributes(ByteVector out) {
+        if (mainClass != 0) {
+            out.putShort(cw.newUTF8("ModuleMainClass")).putInt(2).putShort(mainClass);
+        }
+        if (packages != null) {
+            out.putShort(cw.newUTF8("ModulePackages"))
+               .putInt(2 + 2 * packageCount)
+               .putShort(packageCount)
+               .putByteArray(packages.data, 0, packages.length);
+        }
+    }
+
+    void put(ByteVector out) {
+        out.putInt(size);
+        out.putShort(name).putShort(access).putShort(version);
+        out.putShort(requireCount);
+        if (requires != null) {
+            out.putByteArray(requires.data, 0, requires.length);
+        }
+        out.putShort(exportCount);
+        if (exports != null) {
+            out.putByteArray(exports.data, 0, exports.length);
+        }
+        out.putShort(openCount);
+        if (opens != null) {
+            out.putByteArray(opens.data, 0, opens.length);
+        }
+        out.putShort(useCount);
+        if (uses != null) {
+            out.putByteArray(uses.data, 0, uses.length);
+        }
+        out.putShort(provideCount);
+        if (provides != null) {
+            out.putByteArray(provides.data, 0, provides.length);
+        }
+    }
+}

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

@@ -0,0 +1,402 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+/**
+ * Defines the JVM opcodes, access flags and array type codes. This interface
+ * does not define all the JVM opcodes because some opcodes are automatically
+ * handled. For example, the xLOAD and xSTORE opcodes are automatically replaced
+ * by xLOAD_n and xSTORE_n opcodes when possible. The xLOAD_n and xSTORE_n
+ * opcodes are therefore not defined in this interface. Likewise for LDC,
+ * automatically replaced by LDC_W or LDC2_W when necessary, WIDE, GOTO_W and
+ * JSR_W.
+ *
+ * @author Eric Bruneton
+ * @author Eugene Kuleshov
+ */
+public interface Opcodes {
+
+    // ASM API versions
+    int ASM4 = 4 << 16 | 0 << 8;
+    int ASM5 = 5 << 16 | 0 << 8;
+    int ASM6 = 6 << 16 | 0 << 8;
+
+    // versions
+
+    int V1_1 = 3 << 16 | 45;
+    int V1_2 = 0 << 16 | 46;
+    int V1_3 = 0 << 16 | 47;
+    int V1_4 = 0 << 16 | 48;
+    int V1_5 = 0 << 16 | 49;
+    int V1_6 = 0 << 16 | 50;
+    int V1_7 = 0 << 16 | 51;
+    int V1_8 = 0 << 16 | 52;
+    int V9 = 0 << 16 | 53;
+    int V10 = 0 << 16 | 54;
+    int V11 = 0 << 16 | 55;
+
+    // access flags
+
+    int ACC_PUBLIC = 0x0001; // class, field, method
+    int ACC_PRIVATE = 0x0002; // class, field, method
+    int ACC_PROTECTED = 0x0004; // class, field, method
+    int ACC_STATIC = 0x0008; // field, method
+    int ACC_FINAL = 0x0010; // class, field, method, parameter
+    int ACC_SUPER = 0x0020; // class
+    int ACC_SYNCHRONIZED = 0x0020; // method
+    int ACC_OPEN = 0x0020; // module
+    int ACC_TRANSITIVE = 0x0020; // module requires
+    int ACC_VOLATILE = 0x0040; // field
+    int ACC_BRIDGE = 0x0040; // method
+    int ACC_STATIC_PHASE = 0x0040; // module requires
+    int ACC_VARARGS = 0x0080; // method
+    int ACC_TRANSIENT = 0x0080; // field
+    int ACC_NATIVE = 0x0100; // method
+    int ACC_INTERFACE = 0x0200; // class
+    int ACC_ABSTRACT = 0x0400; // class, method
+    int ACC_STRICT = 0x0800; // method
+    int ACC_SYNTHETIC = 0x1000; // class, field, method, parameter, module *
+    int ACC_ANNOTATION = 0x2000; // class
+    int ACC_ENUM = 0x4000; // class(?) field inner
+    int ACC_MANDATED = 0x8000; // parameter, module, module *
+    int ACC_MODULE = 0x8000; // class
+
+
+    // ASM specific pseudo access flags
+
+    int ACC_DEPRECATED = 0x20000; // class, field, method
+
+    // types for NEWARRAY
+
+    int T_BOOLEAN = 4;
+    int T_CHAR = 5;
+    int T_FLOAT = 6;
+    int T_DOUBLE = 7;
+    int T_BYTE = 8;
+    int T_SHORT = 9;
+    int T_INT = 10;
+    int T_LONG = 11;
+
+    // tags for Handle
+
+    int H_GETFIELD = 1;
+    int H_GETSTATIC = 2;
+    int H_PUTFIELD = 3;
+    int H_PUTSTATIC = 4;
+    int H_INVOKEVIRTUAL = 5;
+    int H_INVOKESTATIC = 6;
+    int H_INVOKESPECIAL = 7;
+    int H_NEWINVOKESPECIAL = 8;
+    int H_INVOKEINTERFACE = 9;
+
+    // stack map frame types
+
+    /**
+     * Represents an expanded frame. See {@link ClassReader#EXPAND_FRAMES}.
+     */
+    int F_NEW = -1;
+
+    /**
+     * Represents a compressed frame with complete frame data.
+     */
+    int F_FULL = 0;
+
+    /**
+     * Represents a compressed frame where locals are the same as the locals in
+     * the previous frame, except that additional 1-3 locals are defined, and
+     * with an empty stack.
+     */
+    int F_APPEND = 1;
+
+    /**
+     * Represents a compressed frame where locals are the same as the locals in
+     * the previous frame, except that the last 1-3 locals are absent and with
+     * an empty stack.
+     */
+    int F_CHOP = 2;
+
+    /**
+     * Represents a compressed frame with exactly the same locals as the
+     * previous frame and with an empty stack.
+     */
+    int F_SAME = 3;
+
+    /**
+     * Represents a compressed frame with exactly the same locals as the
+     * previous frame and with a single value on the stack.
+     */
+    int F_SAME1 = 4;
+
+    // Do not try to change the following code to use auto-boxing,
+    // these values are compared by reference and not by value
+    // The constructor of Integer was deprecated in 9
+    // but we are stuck with it by backward compatibility
+    @SuppressWarnings("deprecation") Integer TOP = new Integer(0);
+    @SuppressWarnings("deprecation") Integer INTEGER = new Integer(1);
+    @SuppressWarnings("deprecation") Integer FLOAT = new Integer(2);
+    @SuppressWarnings("deprecation") Integer DOUBLE = new Integer(3);
+    @SuppressWarnings("deprecation") Integer LONG = new Integer(4);
+    @SuppressWarnings("deprecation") Integer NULL = new Integer(5);
+    @SuppressWarnings("deprecation") Integer UNINITIALIZED_THIS = new Integer(6);
+
+    // opcodes // visit method (- = idem)
+
+    int NOP = 0; // visitInsn
+    int ACONST_NULL = 1; // -
+    int ICONST_M1 = 2; // -
+    int ICONST_0 = 3; // -
+    int ICONST_1 = 4; // -
+    int ICONST_2 = 5; // -
+    int ICONST_3 = 6; // -
+    int ICONST_4 = 7; // -
+    int ICONST_5 = 8; // -
+    int LCONST_0 = 9; // -
+    int LCONST_1 = 10; // -
+    int FCONST_0 = 11; // -
+    int FCONST_1 = 12; // -
+    int FCONST_2 = 13; // -
+    int DCONST_0 = 14; // -
+    int DCONST_1 = 15; // -
+    int BIPUSH = 16; // visitIntInsn
+    int SIPUSH = 17; // -
+    int LDC = 18; // visitLdcInsn
+    // int LDC_W = 19; // -
+    // int LDC2_W = 20; // -
+    int ILOAD = 21; // visitVarInsn
+    int LLOAD = 22; // -
+    int FLOAD = 23; // -
+    int DLOAD = 24; // -
+    int ALOAD = 25; // -
+    // int ILOAD_0 = 26; // -
+    // int ILOAD_1 = 27; // -
+    // int ILOAD_2 = 28; // -
+    // int ILOAD_3 = 29; // -
+    // int LLOAD_0 = 30; // -
+    // int LLOAD_1 = 31; // -
+    // int LLOAD_2 = 32; // -
+    // int LLOAD_3 = 33; // -
+    // int FLOAD_0 = 34; // -
+    // int FLOAD_1 = 35; // -
+    // int FLOAD_2 = 36; // -
+    // int FLOAD_3 = 37; // -
+    // int DLOAD_0 = 38; // -
+    // int DLOAD_1 = 39; // -
+    // int DLOAD_2 = 40; // -
+    // int DLOAD_3 = 41; // -
+    // int ALOAD_0 = 42; // -
+    // int ALOAD_1 = 43; // -
+    // int ALOAD_2 = 44; // -
+    // int ALOAD_3 = 45; // -
+    int IALOAD = 46; // visitInsn
+    int LALOAD = 47; // -
+    int FALOAD = 48; // -
+    int DALOAD = 49; // -
+    int AALOAD = 50; // -
+    int BALOAD = 51; // -
+    int CALOAD = 52; // -
+    int SALOAD = 53; // -
+    int ISTORE = 54; // visitVarInsn
+    int LSTORE = 55; // -
+    int FSTORE = 56; // -
+    int DSTORE = 57; // -
+    int ASTORE = 58; // -
+    // int ISTORE_0 = 59; // -
+    // int ISTORE_1 = 60; // -
+    // int ISTORE_2 = 61; // -
+    // int ISTORE_3 = 62; // -
+    // int LSTORE_0 = 63; // -
+    // int LSTORE_1 = 64; // -
+    // int LSTORE_2 = 65; // -
+    // int LSTORE_3 = 66; // -
+    // int FSTORE_0 = 67; // -
+    // int FSTORE_1 = 68; // -
+    // int FSTORE_2 = 69; // -
+    // int FSTORE_3 = 70; // -
+    // int DSTORE_0 = 71; // -
+    // int DSTORE_1 = 72; // -
+    // int DSTORE_2 = 73; // -
+    // int DSTORE_3 = 74; // -
+    // int ASTORE_0 = 75; // -
+    // int ASTORE_1 = 76; // -
+    // int ASTORE_2 = 77; // -
+    // int ASTORE_3 = 78; // -
+    int IASTORE = 79; // visitInsn
+    int LASTORE = 80; // -
+    int FASTORE = 81; // -
+    int DASTORE = 82; // -
+    int AASTORE = 83; // -
+    int BASTORE = 84; // -
+    int CASTORE = 85; // -
+    int SASTORE = 86; // -
+    int POP = 87; // -
+    int POP2 = 88; // -
+    int DUP = 89; // -
+    int DUP_X1 = 90; // -
+    int DUP_X2 = 91; // -
+    int DUP2 = 92; // -
+    int DUP2_X1 = 93; // -
+    int DUP2_X2 = 94; // -
+    int SWAP = 95; // -
+    int IADD = 96; // -
+    int LADD = 97; // -
+    int FADD = 98; // -
+    int DADD = 99; // -
+    int ISUB = 100; // -
+    int LSUB = 101; // -
+    int FSUB = 102; // -
+    int DSUB = 103; // -
+    int IMUL = 104; // -
+    int LMUL = 105; // -
+    int FMUL = 106; // -
+    int DMUL = 107; // -
+    int IDIV = 108; // -
+    int LDIV = 109; // -
+    int FDIV = 110; // -
+    int DDIV = 111; // -
+    int IREM = 112; // -
+    int LREM = 113; // -
+    int FREM = 114; // -
+    int DREM = 115; // -
+    int INEG = 116; // -
+    int LNEG = 117; // -
+    int FNEG = 118; // -
+    int DNEG = 119; // -
+    int ISHL = 120; // -
+    int LSHL = 121; // -
+    int ISHR = 122; // -
+    int LSHR = 123; // -
+    int IUSHR = 124; // -
+    int LUSHR = 125; // -
+    int IAND = 126; // -
+    int LAND = 127; // -
+    int IOR = 128; // -
+    int LOR = 129; // -
+    int IXOR = 130; // -
+    int LXOR = 131; // -
+    int IINC = 132; // visitIincInsn
+    int I2L = 133; // visitInsn
+    int I2F = 134; // -
+    int I2D = 135; // -
+    int L2I = 136; // -
+    int L2F = 137; // -
+    int L2D = 138; // -
+    int F2I = 139; // -
+    int F2L = 140; // -
+    int F2D = 141; // -
+    int D2I = 142; // -
+    int D2L = 143; // -
+    int D2F = 144; // -
+    int I2B = 145; // -
+    int I2C = 146; // -
+    int I2S = 147; // -
+    int LCMP = 148; // -
+    int FCMPL = 149; // -
+    int FCMPG = 150; // -
+    int DCMPL = 151; // -
+    int DCMPG = 152; // -
+    int IFEQ = 153; // visitJumpInsn
+    int IFNE = 154; // -
+    int IFLT = 155; // -
+    int IFGE = 156; // -
+    int IFGT = 157; // -
+    int IFLE = 158; // -
+    int IF_ICMPEQ = 159; // -
+    int IF_ICMPNE = 160; // -
+    int IF_ICMPLT = 161; // -
+    int IF_ICMPGE = 162; // -
+    int IF_ICMPGT = 163; // -
+    int IF_ICMPLE = 164; // -
+    int IF_ACMPEQ = 165; // -
+    int IF_ACMPNE = 166; // -
+    int GOTO = 167; // -
+    int JSR = 168; // -
+    int RET = 169; // visitVarInsn
+    int TABLESWITCH = 170; // visiTableSwitchInsn
+    int LOOKUPSWITCH = 171; // visitLookupSwitch
+    int IRETURN = 172; // visitInsn
+    int LRETURN = 173; // -
+    int FRETURN = 174; // -
+    int DRETURN = 175; // -
+    int ARETURN = 176; // -
+    int RETURN = 177; // -
+    int GETSTATIC = 178; // visitFieldInsn
+    int PUTSTATIC = 179; // -
+    int GETFIELD = 180; // -
+    int PUTFIELD = 181; // -
+    int INVOKEVIRTUAL = 182; // visitMethodInsn
+    int INVOKESPECIAL = 183; // -
+    int INVOKESTATIC = 184; // -
+    int INVOKEINTERFACE = 185; // -
+    int INVOKEDYNAMIC = 186; // visitInvokeDynamicInsn
+    int NEW = 187; // visitTypeInsn
+    int NEWARRAY = 188; // visitIntInsn
+    int ANEWARRAY = 189; // visitTypeInsn
+    int ARRAYLENGTH = 190; // visitInsn
+    int ATHROW = 191; // -
+    int CHECKCAST = 192; // visitTypeInsn
+    int INSTANCEOF = 193; // -
+    int MONITORENTER = 194; // visitInsn
+    int MONITOREXIT = 195; // -
+    // int WIDE = 196; // NOT VISITED
+    int MULTIANEWARRAY = 197; // visitMultiANewArrayInsn
+    int IFNULL = 198; // visitJumpInsn
+    int IFNONNULL = 199; // -
+    // int GOTO_W = 200; // -
+    // int JSR_W = 201; // -
+}

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

@@ -0,0 +1,934 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2011 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.redkale.asm;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+
+/**
+ * A Java field or method type. This class can be used to make it easier to
+ * manipulate type and method descriptors.
+ *
+ * @author Eric Bruneton
+ * @author Chris Nokleberg
+ */
+public class Type {
+
+    /**
+     * The sort of the <tt>void</tt> type. See {@link #getSort getSort}.
+     */
+    public static final int VOID = 0;
+
+    /**
+     * The sort of the <tt>boolean</tt> type. See {@link #getSort getSort}.
+     */
+    public static final int BOOLEAN = 1;
+
+    /**
+     * The sort of the <tt>char</tt> type. See {@link #getSort getSort}.
+     */
+    public static final int CHAR = 2;
+
+    /**
+     * The sort of the <tt>byte</tt> type. See {@link #getSort getSort}.
+     */
+    public static final int BYTE = 3;
+
+    /**
+     * The sort of the <tt>short</tt> type. See {@link #getSort getSort}.
+     */
+    public static final int SHORT = 4;
+
+    /**
+     * The sort of the <tt>int</tt> type. See {@link #getSort getSort}.
+     */
+    public static final int INT = 5;
+
+    /**
+     * The sort of the <tt>float</tt> type. See {@link #getSort getSort}.
+     */
+    public static final int FLOAT = 6;
+
+    /**
+     * The sort of the <tt>long</tt> type. See {@link #getSort getSort}.
+     */
+    public static final int LONG = 7;
+
+    /**
+     * The sort of the <tt>double</tt> type. See {@link #getSort getSort}.
+     */
+    public static final int DOUBLE = 8;
+
+    /**
+     * The sort of array reference types. See {@link #getSort getSort}.
+     */
+    public static final int ARRAY = 9;
+
+    /**
+     * The sort of object reference types. See {@link #getSort getSort}.
+     */
+    public static final int OBJECT = 10;
+
+    /**
+     * The sort of method types. See {@link #getSort getSort}.
+     */
+    public static final int METHOD = 11;
+
+    /**
+     * The <tt>void</tt> type.
+     */
+    public static final Type VOID_TYPE = new Type(VOID, null, ('V' << 24)
+            | (5 << 16) | (0 << 8) | 0, 1);
+
+    /**
+     * The &#60;tt&#62;boolean&#60;/tt&#62; type.
+     */
+    public static final Type BOOLEAN_TYPE = new Type(BOOLEAN, null, ('Z' << 24)
+            | (0 << 16) | (5 << 8) | 1, 1);
+
+    /**
+     * The &#60;tt&#62;char&#60;/tt&#62; type.
+     */
+    public static final Type CHAR_TYPE = new Type(CHAR, null, ('C' << 24)
+            | (0 << 16) | (6 << 8) | 1, 1);
+
+    /**
+     * The &#60;tt&#62;byte&#60;/tt&#62; type.
+     */
+    public static final Type BYTE_TYPE = new Type(BYTE, null, ('B' << 24)
+            | (0 << 16) | (5 << 8) | 1, 1);
+
+    /**
+     * The &#60;tt&#62;short&#60;/tt&#62; type.
+     */
+    public static final Type SHORT_TYPE = new Type(SHORT, null, ('S' << 24)
+            | (0 << 16) | (7 << 8) | 1, 1);
+
+    /**
+     * The &#60;tt&#62;int&#60;/tt&#62; type.
+     */
+    public static final Type INT_TYPE = new Type(INT, null, ('I' << 24)
+            | (0 << 16) | (0 << 8) | 1, 1);
+
+    /**
+     * The &#60;tt&#62;float&#60;/tt&#62; type.
+     */
+    public static final Type FLOAT_TYPE = new Type(FLOAT, null, ('F' << 24)
+            | (2 << 16) | (2 << 8) | 1, 1);
+
+    /**
+     * The &#60;tt&#62;long&#60;/tt&#62; type.
+     */
+    public static final Type LONG_TYPE = new Type(LONG, null, ('J' << 24)
+            | (1 << 16) | (1 << 8) | 2, 1);
+
+    /**
+     * The &#60;tt&#62;double&#60;/tt&#62; type.
+     */
+    public static final Type DOUBLE_TYPE = new Type(DOUBLE, null, ('D' << 24)
+            | (3 << 16) | (3 << 8) | 2, 1);
+
+    // ------------------------------------------------------------------------
+    // Fields
+    // ------------------------------------------------------------------------
+
+    /**
+     * The sort of this Java type.
+     */
+    private final int sort;
+
+    /**
+     * A buffer containing the internal name of this Java type. This field is
+     * only used for reference types.
+     */
+    private final char[] buf;
+
+    /**
+     * The offset of the internal name of this Java type in {@link #buf buf} or,
+     * for primitive types, the size, descriptor and getOpcode offsets for this
+     * type (byte 0 contains the size, byte 1 the descriptor, byte 2 the offset
+     * for IALOAD or IASTORE, byte 3 the offset for all other instructions).
+     */
+    private final int off;
+
+    /**
+     * The length of the internal name of this Java type.
+     */
+    private final int len;
+
+    // ------------------------------------------------------------------------
+    // Constructors
+    // ------------------------------------------------------------------------
+
+    /**
+     * Constructs a reference type.
+     *
+     * @param sort
+     *            the sort of the reference type to be constructed.
+     * @param buf
+     *            a buffer containing the descriptor of the previous type.
+     * @param off
+     *            the offset of this descriptor in the previous buffer.
+     * @param len
+     *            the length of this descriptor.
+     */
+    private Type(final int sort, final char[] buf, final int off, final int len) {
+        this.sort = sort;
+        this.buf = buf;
+        this.off = off;
+        this.len = len;
+    }
+
+    /**
+     * Returns the Java type corresponding to the given type descriptor.
+     *
+     * @param typeDescriptor
+     *            a field or method type descriptor.
+     * @return the Java type corresponding to the given type descriptor.
+     */
+    public static Type getType(final String typeDescriptor) {
+        return getType(typeDescriptor.toCharArray(), 0);
+    }
+
+    /**
+     * Returns the Java type corresponding to the given internal name.
+     *
+     * @param internalName
+     *            an internal name.
+     * @return the Java type corresponding to the given internal name.
+     */
+    public static Type getObjectType(final String internalName) {
+        char[] buf = internalName.toCharArray();
+        return new Type(buf[0] == '[' ? ARRAY : OBJECT, buf, 0, buf.length);
+    }
+
+    /**
+     * Returns the Java type corresponding to the given method descriptor.
+     * Equivalent to <code>Type.getType(methodDescriptor)</code>.
+     *
+     * @param methodDescriptor
+     *            a method descriptor.
+     * @return the Java type corresponding to the given method descriptor.
+     */
+    public static Type getMethodType(final String methodDescriptor) {
+        return getType(methodDescriptor.toCharArray(), 0);
+    }
+
+    /**
+     * Returns the Java method type corresponding to the given argument and
+     * return types.
+     *
+     * @param returnType
+     *            the return type of the method.
+     * @param argumentTypes
+     *            the argument types of the method.
+     * @return the Java type corresponding to the given argument and return
+     *         types.
+     */
+    public static Type getMethodType(final Type returnType,
+            final Type... argumentTypes) {
+        return getType(getMethodDescriptor(returnType, argumentTypes));
+    }
+
+    /**
+     * Returns the Java type corresponding to the given class.
+     *
+     * @param c
+     *            a class.
+     * @return the Java type corresponding to the given class.
+     */
+    public static Type getType(final Class<?> c) {
+        if (c.isPrimitive()) {
+            if (c == Integer.TYPE) {
+                return INT_TYPE;
+            } else if (c == Void.TYPE) {
+                return VOID_TYPE;
+            } else if (c == Boolean.TYPE) {
+                return BOOLEAN_TYPE;
+            } else if (c == Byte.TYPE) {
+                return BYTE_TYPE;
+            } else if (c == Character.TYPE) {
+                return CHAR_TYPE;
+            } else if (c == Short.TYPE) {
+                return SHORT_TYPE;
+            } else if (c == Double.TYPE) {
+                return DOUBLE_TYPE;
+            } else if (c == Float.TYPE) {
+                return FLOAT_TYPE;
+            } else /* if (c == Long.TYPE) */{
+                return LONG_TYPE;
+            }
+        } else {
+            return getType(getDescriptor(c));
+        }
+    }
+
+    /**
+     * Returns the Java method type corresponding to the given constructor.
+     *
+     * @param c
+     *            a {@link Constructor Constructor} object.
+     * @return the Java method type corresponding to the given constructor.
+     */
+    public static Type getType(final Constructor<?> c) {
+        return getType(getConstructorDescriptor(c));
+    }
+
+    /**
+     * Returns the Java method type corresponding to the given method.
+     *
+     * @param m
+     *            a {@link Method Method} object.
+     * @return the Java method type corresponding to the given method.
+     */
+    public static Type getType(final Method m) {
+        return getType(getMethodDescriptor(m));
+    }
+
+    /**
+     * Returns the Java types corresponding to the argument types of the given
+     * method descriptor.
+     *
+     * @param methodDescriptor
+     *            a method descriptor.
+     * @return the Java types corresponding to the argument types of the given
+     *         method descriptor.
+     */
+    public static Type[] getArgumentTypes(final String methodDescriptor) {
+        char[] buf = methodDescriptor.toCharArray();
+        int off = 1;
+        int size = 0;
+        while (true) {
+            char car = buf[off++];
+            if (car == ')') {
+                break;
+            } else if (car == 'L') {
+                while (buf[off++] != ';') {
+                }
+                ++size;
+            } else if (car != '[') {
+                ++size;
+            }
+        }
+        Type[] args = new Type[size];
+        off = 1;
+        size = 0;
+        while (buf[off] != ')') {
+            args[size] = getType(buf, off);
+            off += args[size].len + (args[size].sort == OBJECT ? 2 : 0);
+            size += 1;
+        }
+        return args;
+    }
+
+    /**
+     * Returns the Java types corresponding to the argument types of the given
+     * method.
+     *
+     * @param method
+     *            a method.
+     * @return the Java types corresponding to the argument types of the given
+     *         method.
+     */
+    public static Type[] getArgumentTypes(final Method method) {
+        Class<?>[] classes = method.getParameterTypes();
+        Type[] types = new Type[classes.length];
+        for (int i = classes.length - 1; i >= 0; --i) {
+            types[i] = getType(classes[i]);
+        }
+        return types;
+    }
+
+    /**
+     * Returns the Java type corresponding to the return type of the given
+     * method descriptor.
+     *
+     * @param methodDescriptor
+     *            a method descriptor.
+     * @return the Java type corresponding to the return type of the given
+     *         method descriptor.
+     */
+    public static Type getReturnType(final String methodDescriptor) {
+        char[] buf = methodDescriptor.toCharArray();
+        int off = 1;
+        while (true) {
+            char car = buf[off++];
+            if (car == ')') {
+                return getType(buf, off);
+            } else if (car == 'L') {
+                while (buf[off++] != ';') {
+                }
+            }
+        }
+    }
+
+    /**
+     * Returns the Java type corresponding to the return type of the given
+     * method.
+     *
+     * @param method
+     *            a method.
+     * @return the Java type corresponding to the return type of the given
+     *         method.
+     */
+    public static Type getReturnType(final Method method) {
+        return getType(method.getReturnType());
+    }
+
+    /**
+     * Computes the size of the arguments and of the return value of a method.
+     *
+     * @param desc
+     *            the descriptor of a method.
+     * @return the size of the arguments of the method (plus one for the
+     *         implicit this argument), argSize, and the size of its return
+     *         value, retSize, packed into a single int i =
+     *         &#60;tt&#62;(argSize &lt;&lt; 2) | retSize&#60;/tt&#62; (argSize is therefore equal to
+     *         &#60;tt&#62;i &gt;&gt; 2&#60;/tt&#62;, and retSize to &#60;tt&#62;i &amp; 0x03&#60;/tt&#62;).
+     */
+    public static int getArgumentsAndReturnSizes(final String desc) {
+        int n = 1;
+        int c = 1;
+        while (true) {
+            char car = desc.charAt(c++);
+            if (car == ')') {
+                car = desc.charAt(c);
+                return n << 2
+                        | (car == 'V' ? 0 : (car == 'D' || car == 'J' ? 2 : 1));
+            } else if (car == 'L') {
+                while (desc.charAt(c++) != ';') {
+                }
+                n += 1;
+            } else if (car == '[') {
+                while ((car = desc.charAt(c)) == '[') {
+                    ++c;
+                }
+                if (car == 'D' || car == 'J') {
+                    n -= 1;
+                }
+            } else if (car == 'D' || car == 'J') {
+                n += 2;
+            } else {
+                n += 1;
+            }
+        }
+    }
+
+    /**
+     * Returns the Java type corresponding to the given type descriptor. For
+     * method descriptors, buf is supposed to contain nothing more than the
+     * descriptor itself.
+     *
+     * @param buf
+     *            a buffer containing a type descriptor.
+     * @param off
+     *            the offset of this descriptor in the previous buffer.
+     * @return the Java type corresponding to the given type descriptor.
+     */
+    private static Type getType(final char[] buf, final int off) {
+        int len;
+        switch (buf[off]) {
+        case 'V':
+            return VOID_TYPE;
+        case 'Z':
+            return BOOLEAN_TYPE;
+        case 'C':
+            return CHAR_TYPE;
+        case 'B':
+            return BYTE_TYPE;
+        case 'S':
+            return SHORT_TYPE;
+        case 'I':
+            return INT_TYPE;
+        case 'F':
+            return FLOAT_TYPE;
+        case 'J':
+            return LONG_TYPE;
+        case 'D':
+            return DOUBLE_TYPE;
+        case '[':
+            len = 1;
+            while (buf[off + len] == '[') {
+                ++len;
+            }
+            if (buf[off + len] == 'L') {
+                ++len;
+                while (buf[off + len] != ';') {
+                    ++len;
+                }
+            }
+            return new Type(ARRAY, buf, off, len + 1);
+        case 'L':
+            len = 1;
+            while (buf[off + len] != ';') {
+                ++len;
+            }
+            return new Type(OBJECT, buf, off + 1, len - 1);
+            // case '(':
+        default:
+            return new Type(METHOD, buf, off, buf.length - off);
+        }
+    }
+
+    // ------------------------------------------------------------------------
+    // Accessors
+    // ------------------------------------------------------------------------
+
+    /**
+     * Returns the sort of this Java type.
+     *
+     * @return {@link #VOID VOID}, {@link #BOOLEAN BOOLEAN}, {@link #CHAR CHAR},
+     *         {@link #BYTE BYTE}, {@link #SHORT SHORT}, {@link #INT INT},
+     *         {@link #FLOAT FLOAT}, {@link #LONG LONG}, {@link #DOUBLE DOUBLE},
+     *         {@link #ARRAY ARRAY}, {@link #OBJECT OBJECT} or {@link #METHOD
+     *         METHOD}.
+     */
+    public int getSort() {
+        return sort;
+    }
+
+    /**
+     * Returns the number of dimensions of this array type. This method should
+     * only be used for an array type.
+     *
+     * @return the number of dimensions of this array type.
+     */
+    public int getDimensions() {
+        int i = 1;
+        while (buf[off + i] == '[') {
+            ++i;
+        }
+        return i;
+    }
+
+    /**
+     * Returns the type of the elements of this array type. This method should
+     * only be used for an array type.
+     *
+     * @return Returns the type of the elements of this array type.
+     */
+    public Type getElementType() {
+        return getType(buf, off + getDimensions());
+    }
+
+    /**
+     * Returns the binary name of the class corresponding to this type. This
+     * method must not be used on method types.
+     *
+     * @return the binary name of the class corresponding to this type.
+     */
+    public String getClassName() {
+        switch (sort) {
+        case VOID:
+            return "void";
+        case BOOLEAN:
+            return "boolean";
+        case CHAR:
+            return "char";
+        case BYTE:
+            return "byte";
+        case SHORT:
+            return "short";
+        case INT:
+            return "int";
+        case FLOAT:
+            return "float";
+        case LONG:
+            return "long";
+        case DOUBLE:
+            return "double";
+        case ARRAY:
+            StringBuilder sb = new StringBuilder(getElementType().getClassName());
+            for (int i = getDimensions(); i > 0; --i) {
+                sb.append("[]");
+            }
+            return sb.toString();
+        case OBJECT:
+            return new String(buf, off, len).replace('/', '.');
+        default:
+            return null;
+        }
+    }
+
+    /**
+     * Returns the internal name of the class corresponding to this object or
+     * array type. The internal name of a class is its fully qualified name (as
+     * returned by Class.getName(), where '.' are replaced by '/'. This method
+     * should only be used for an object or array type.
+     *
+     * @return the internal name of the class corresponding to this object type.
+     */
+    public String getInternalName() {
+        return new String(buf, off, len);
+    }
+
+    /**
+     * Returns the argument types of methods of this type. This method should
+     * only be used for method types.
+     *
+     * @return the argument types of methods of this type.
+     */
+    public Type[] getArgumentTypes() {
+        return getArgumentTypes(getDescriptor());
+    }
+
+    /**
+     * Returns the return type of methods of this type. This method should only
+     * be used for method types.
+     *
+     * @return the return type of methods of this type.
+     */
+    public Type getReturnType() {
+        return getReturnType(getDescriptor());
+    }
+
+    /**
+     * Returns the size of the arguments and of the return value of methods of
+     * this type. This method should only be used for method types.
+     *
+     * @return the size of the arguments (plus one for the implicit this
+     *         argument), argSize, and the size of the return value, retSize,
+     *         packed into a single
+     *         int i = &#60;tt&#62;(argSize &lt;&lt; 2) | retSize&#60;/tt&#62;
+     *         (argSize is therefore equal to &#60;tt&#62;i &gt;&gt; 2&#60;/tt&#62;,
+     *         and retSize to &#60;tt&#62;i &amp; 0x03&#60;/tt&#62;).
+     */
+    public int getArgumentsAndReturnSizes() {
+        return getArgumentsAndReturnSizes(getDescriptor());
+    }
+
+    // ------------------------------------------------------------------------
+    // Conversion to type descriptors
+    // ------------------------------------------------------------------------
+
+    /**
+     * Returns the descriptor corresponding to this Java type.
+     *
+     * @return the descriptor corresponding to this Java type.
+     */
+    public String getDescriptor() {
+        StringBuilder buf = new StringBuilder();
+        getDescriptor(buf);
+        return buf.toString();
+    }
+
+    /**
+     * Returns the descriptor corresponding to the given argument and return
+     * types.
+     *
+     * @param returnType
+     *            the return type of the method.
+     * @param argumentTypes
+     *            the argument types of the method.
+     * @return the descriptor corresponding to the given argument and return
+     *         types.
+     */
+    public static String getMethodDescriptor(final Type returnType,
+            final Type... argumentTypes) {
+        StringBuilder buf = new StringBuilder();
+        buf.append('(');
+        for (int i = 0; i < argumentTypes.length; ++i) {
+            argumentTypes[i].getDescriptor(buf);
+        }
+        buf.append(')');
+        returnType.getDescriptor(buf);
+        return buf.toString();
+    }
+
+    /**
+     * Appends the descriptor corresponding to this Java type to the given
+     * string buffer.
+     *
+     * @param buf
+     *            the string buffer to which the descriptor must be appended.
+     */
+    private void getDescriptor(final StringBuilder buf) {
+        if (this.buf == null) {
+            // descriptor is in byte 3 of 'off' for primitive types (buf ==
+            // null)
+            buf.append((char) ((off & 0xFF000000) >>> 24));
+        } else if (sort == OBJECT) {
+            buf.append('L');
+            buf.append(this.buf, off, len);
+            buf.append(';');
+        } else { // sort == ARRAY || sort == METHOD
+            buf.append(this.buf, off, len);
+        }
+    }
+
+    // ------------------------------------------------------------------------
+    // Direct conversion from classes to type descriptors,
+    // without intermediate Type objects
+    // ------------------------------------------------------------------------
+
+    /**
+     * Returns the internal name of the given class. The internal name of a
+     * class is its fully qualified name, as returned by Class.getName(), where
+     * '.' are replaced by '/'.
+     *
+     * @param c
+     *            an object or array class.
+     * @return the internal name of the given class.
+     */
+    public static String getInternalName(final Class<?> c) {
+        return c.getName().replace('.', '/');
+    }
+
+    /**
+     * Returns the descriptor corresponding to the given Java type.
+     *
+     * @param c
+     *            an object class, a primitive class or an array class.
+     * @return the descriptor corresponding to the given class.
+     */
+    public static String getDescriptor(final Class<?> c) {
+        StringBuilder buf = new StringBuilder();
+        getDescriptor(buf, c);
+        return buf.toString();
+    }
+
+    /**
+     * Returns the descriptor corresponding to the given constructor.
+     *
+     * @param c
+     *            a {@link Constructor Constructor} object.
+     * @return the descriptor of the given constructor.
+     */
+    public static String getConstructorDescriptor(final Constructor<?> c) {
+        Class<?>[] parameters = c.getParameterTypes();
+        StringBuilder buf = new StringBuilder();
+        buf.append('(');
+        for (int i = 0; i < parameters.length; ++i) {
+            getDescriptor(buf, parameters[i]);
+        }
+        return buf.append(")V").toString();
+    }
+
+    /**
+     * Returns the descriptor corresponding to the given method.
+     *
+     * @param m
+     *            a {@link Method Method} object.
+     * @return the descriptor of the given method.
+     */
+    public static String getMethodDescriptor(final Method m) {
+        Class<?>[] parameters = m.getParameterTypes();
+        StringBuilder buf = new StringBuilder();
+        buf.append('(');
+        for (int i = 0; i < parameters.length; ++i) {
+            getDescriptor(buf, parameters[i]);
+        }
+        buf.append(')');
+        getDescriptor(buf, m.getReturnType());
+        return buf.toString();
+    }
+
+    /**
+     * Appends the descriptor of the given class to the given string buffer.
+     *
+     * @param buf
+     *            the string buffer to which the descriptor must be appended.
+     * @param c
+     *            the class whose descriptor must be computed.
+     */
+    private static void getDescriptor(final StringBuilder buf, final Class<?> c) {
+        Class<?> d = c;
+        while (true) {
+            if (d.isPrimitive()) {
+                char car;
+                if (d == Integer.TYPE) {
+                    car = 'I';
+                } else if (d == Void.TYPE) {
+                    car = 'V';
+                } else if (d == Boolean.TYPE) {
+                    car = 'Z';
+                } else if (d == Byte.TYPE) {
+                    car = 'B';
+                } else if (d == Character.TYPE) {
+                    car = 'C';
+                } else if (d == Short.TYPE) {
+                    car = 'S';
+                } else if (d == Double.TYPE) {
+                    car = 'D';
+                } else if (d == Float.TYPE) {
+                    car = 'F';
+                } else /* if (d == Long.TYPE) */{
+                    car = 'J';
+                }
+                buf.append(car);
+                return;
+            } else if (d.isArray()) {
+                buf.append('[');
+                d = d.getComponentType();
+            } else {
+                buf.append('L');
+                String name = d.getName();
+                int len = name.length();
+                for (int i = 0; i < len; ++i) {
+                    char car = name.charAt(i);
+                    buf.append(car == '.' ? '/' : car);
+                }
+                buf.append(';');
+                return;
+            }
+        }
+    }
+
+    // ------------------------------------------------------------------------
+    // Corresponding size and opcodes
+    // ------------------------------------------------------------------------
+
+    /**
+     * Returns the size of values of this type. This method must not be used for
+     * method types.
+     *
+     * @return the size of values of this type, i.e., 2 for &#60;tt&#62;long&#60;/tt&#62; and
+     *         &#60;tt&#62;double&#60;/tt&#62;, 0 for &#60;tt&#62;void&#60;/tt&#62; and 1 otherwise.
+     */
+    public int getSize() {
+        // the size is in byte 0 of 'off' for primitive types (buf == null)
+        return buf == null ? (off & 0xFF) : 1;
+    }
+
+    /**
+     * Returns a JVM instruction opcode adapted to this Java type. This method
+     * must not be used for method types.
+     *
+     * @param opcode
+     *            a JVM instruction opcode. This opcode must be one of ILOAD,
+     *            ISTORE, IALOAD, IASTORE, IADD, ISUB, IMUL, IDIV, IREM, INEG,
+     *            ISHL, ISHR, IUSHR, IAND, IOR, IXOR and IRETURN.
+     * @return an opcode that is similar to the given opcode, but adapted to
+     *         this Java type. For example, if this type is &#60;tt&#62;float&#60;/tt&#62; and
+     *         &#60;tt&#62;opcode&#60;/tt&#62; is IRETURN, this method returns FRETURN.
+     */
+    public int getOpcode(final int opcode) {
+        if (opcode == Opcodes.IALOAD || opcode == Opcodes.IASTORE) {
+            // the offset for IALOAD or IASTORE is in byte 1 of 'off' for
+            // primitive types (buf == null)
+            return opcode + (buf == null ? (off & 0xFF00) >> 8 : 4);
+        } else {
+            // the offset for other instructions is in byte 2 of 'off' for
+            // primitive types (buf == null)
+            return opcode + (buf == null ? (off & 0xFF0000) >> 16 : 4);
+        }
+    }
+
+    // ------------------------------------------------------------------------
+    // Equals, hashCode and toString
+    // ------------------------------------------------------------------------
+
+    /**
+     * Tests if the given object is equal to this type.
+     *
+     * @param o
+     *            the object to be compared to this type.
+     * @return &#60;tt&#62;true&#60;/tt&#62; if the given object is equal to this type.
+     */
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof Type)) {
+            return false;
+        }
+        Type t = (Type) o;
+        if (sort != t.sort) {
+            return false;
+        }
+        if (sort >= ARRAY) {
+            if (len != t.len) {
+                return false;
+            }
+            for (int i = off, j = t.off, end = i + len; i < end; i++, j++) {
+                if (buf[i] != t.buf[j]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Returns a hash code value for this type.
+     *
+     * @return a hash code value for this type.
+     */
+    @Override
+    public int hashCode() {
+        int hc = 13 * sort;
+        if (sort >= ARRAY) {
+            for (int i = off, end = i + len; i < end; i++) {
+                hc = 17 * (hc + buf[i]);
+            }
+        }
+        return hc;
+    }
+
+    /**
+     * Returns a string representation of this type.
+     *
+     * @return the descriptor of this type.
+     */
+    @Override
+    public String toString() {
+        return getDescriptor();
+    }
+}

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

@@ -0,0 +1,225 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2013 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.redkale.asm;
+
+/**
+ * The path to a type argument, wildcard bound, array element type, or static
+ * inner type within an enclosing type.
+ *
+ * @author Eric Bruneton
+ */
+public class TypePath {
+
+    /**
+     * A type path step that steps into the element type of an array type. See
+     * {@link #getStep getStep}.
+     */
+    public final static int ARRAY_ELEMENT = 0;
+
+    /**
+     * A type path step that steps into the nested type of a class type. See
+     * {@link #getStep getStep}.
+     */
+    public final static int INNER_TYPE = 1;
+
+    /**
+     * A type path step that steps into the bound of a wildcard type. See
+     * {@link #getStep getStep}.
+     */
+    public final static int WILDCARD_BOUND = 2;
+
+    /**
+     * A type path step that steps into a type argument of a generic type. See
+     * {@link #getStep getStep}.
+     */
+    public final static int TYPE_ARGUMENT = 3;
+
+    /**
+     * The byte array where the path is stored, in Java class file format.
+     */
+    byte[] b;
+
+    /**
+     * The offset of the first byte of the type path in 'b'.
+     */
+    int offset;
+
+    /**
+     * Creates a new type path.
+     *
+     * @param b
+     *            the byte array containing the type path in Java class file
+     *            format.
+     * @param offset
+     *            the offset of the first byte of the type path in 'b'.
+     */
+    TypePath(byte[] b, int offset) {
+        this.b = b;
+        this.offset = offset;
+    }
+
+    /**
+     * Returns the length of this path.
+     *
+     * @return the length of this path.
+     */
+    public int getLength() {
+        return b[offset];
+    }
+
+    /**
+     * Returns the value of the given step of this path.
+     *
+     * @param index
+     *            an index between 0 and {@link #getLength()}, exclusive.
+     * @return {@link #ARRAY_ELEMENT ARRAY_ELEMENT}, {@link #INNER_TYPE
+     *         INNER_TYPE}, {@link #WILDCARD_BOUND WILDCARD_BOUND}, or
+     *         {@link #TYPE_ARGUMENT TYPE_ARGUMENT}.
+     */
+    public int getStep(int index) {
+        return b[offset + 2 * index + 1];
+    }
+
+    /**
+     * Returns the index of the type argument that the given step is stepping
+     * into. This method should only be used for steps whose value is
+     * {@link #TYPE_ARGUMENT TYPE_ARGUMENT}.
+     *
+     * @param index
+     *            an index between 0 and {@link #getLength()}, exclusive.
+     * @return the index of the type argument that the given step is stepping
+     *         into.
+     */
+    public int getStepArgument(int index) {
+        return b[offset + 2 * index + 2];
+    }
+
+    /**
+     * Converts a type path in string form, in the format used by
+     * {@link #toString()}, into a TypePath object.
+     *
+     * @param typePath
+     *            a type path in string form, in the format used by
+     *            {@link #toString()}. May be null or empty.
+     * @return the corresponding TypePath object, or null if the path is empty.
+     */
+    public static TypePath fromString(final String typePath) {
+        if (typePath == null || typePath.isEmpty()) {
+            return null;
+        }
+        int n = typePath.length();
+        ByteVector out = new ByteVector(n);
+        out.putByte(0);
+        for (int i = 0; i < n;) {
+            char c = typePath.charAt(i++);
+            if (c == '[') {
+                out.put11(ARRAY_ELEMENT, 0);
+            } else if (c == '.') {
+                out.put11(INNER_TYPE, 0);
+            } else if (c == '*') {
+                out.put11(WILDCARD_BOUND, 0);
+            } else if (c >= '0' && c <= '9') {
+                int typeArg = c - '0';
+                while (i < n && (c = typePath.charAt(i)) >= '0' && c <= '9') {
+                    typeArg = typeArg * 10 + c - '0';
+                    i += 1;
+                }
+                if (i < n && typePath.charAt(i) == ';') {
+                    i += 1;
+                }
+                out.put11(TYPE_ARGUMENT, typeArg);
+            }
+        }
+        out.data[0] = (byte) (out.length / 2);
+        return new TypePath(out.data, 0);
+    }
+
+    /**
+     * Returns a string representation of this type path. {@link #ARRAY_ELEMENT
+     * ARRAY_ELEMENT} steps are represented with '[', {@link #INNER_TYPE
+     * INNER_TYPE} steps with '.', {@link #WILDCARD_BOUND WILDCARD_BOUND} steps
+     * with '*' and {@link #TYPE_ARGUMENT TYPE_ARGUMENT} steps with their type
+     * argument index in decimal form followed by ';'.
+     */
+    @Override
+    public String toString() {
+        int length = getLength();
+        StringBuilder result = new StringBuilder(length * 2);
+        for (int i = 0; i < length; ++i) {
+            switch (getStep(i)) {
+            case ARRAY_ELEMENT:
+                result.append('[');
+                break;
+            case INNER_TYPE:
+                result.append('.');
+                break;
+            case WILDCARD_BOUND:
+                result.append('*');
+                break;
+            case TYPE_ARGUMENT:
+                result.append(getStepArgument(i)).append(';');
+                break;
+            default:
+                result.append('_');
+            }
+        }
+        return result.toString();
+    }
+}

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

@@ -0,0 +1,481 @@
+/*
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+/*
+ *
+ *
+ *
+ *
+ *
+ * ASM: a very small and fast Java bytecode manipulation framework
+ * Copyright (c) 2000-2013 INRIA, France Telecom
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package org.redkale.asm;
+
+/**
+ * A reference to a type appearing in a class, field or method declaration, or
+ * on an instruction. Such a reference designates the part of the class where
+ * the referenced type is appearing (e.g. an 'extends', 'implements' or 'throws'
+ * clause, a 'new' instruction, a 'catch' clause, a type cast, a local variable
+ * declaration, etc).
+ *
+ * @author Eric Bruneton
+ */
+public class TypeReference {
+
+    /**
+     * The sort of type references that target a type parameter of a generic
+     * class. See {@link #getSort getSort}.
+     */
+    public final static int CLASS_TYPE_PARAMETER = 0x00;
+
+    /**
+     * The sort of type references that target a type parameter of a generic
+     * method. See {@link #getSort getSort}.
+     */
+    public final static int METHOD_TYPE_PARAMETER = 0x01;
+
+    /**
+     * The sort of type references that target the super class of a class or one
+     * of the interfaces it implements. See {@link #getSort getSort}.
+     */
+    public final static int CLASS_EXTENDS = 0x10;
+
+    /**
+     * The sort of type references that target a bound of a type parameter of a
+     * generic class. See {@link #getSort getSort}.
+     */
+    public final static int CLASS_TYPE_PARAMETER_BOUND = 0x11;
+
+    /**
+     * The sort of type references that target a bound of a type parameter of a
+     * generic method. See {@link #getSort getSort}.
+     */
+    public final static int METHOD_TYPE_PARAMETER_BOUND = 0x12;
+
+    /**
+     * The sort of type references that target the type of a field. See
+     * {@link #getSort getSort}.
+     */
+    public final static int FIELD = 0x13;
+
+    /**
+     * The sort of type references that target the return type of a method. See
+     * {@link #getSort getSort}.
+     */
+    public final static int METHOD_RETURN = 0x14;
+
+    /**
+     * The sort of type references that target the receiver type of a method.
+     * See {@link #getSort getSort}.
+     */
+    public final static int METHOD_RECEIVER = 0x15;
+
+    /**
+     * The sort of type references that target the type of a formal parameter of
+     * a method. See {@link #getSort getSort}.
+     */
+    public final static int METHOD_FORMAL_PARAMETER = 0x16;
+
+    /**
+     * The sort of type references that target the type of an exception declared
+     * in the throws clause of a method. See {@link #getSort getSort}.
+     */
+    public final static int THROWS = 0x17;
+
+    /**
+     * The sort of type references that target the type of a local variable in a
+     * method. See {@link #getSort getSort}.
+     */
+    public final static int LOCAL_VARIABLE = 0x40;
+
+    /**
+     * The sort of type references that target the type of a resource variable
+     * in a method. See {@link #getSort getSort}.
+     */
+    public final static int RESOURCE_VARIABLE = 0x41;
+
+    /**
+     * The sort of type references that target the type of the exception of a
+     * 'catch' clause in a method. See {@link #getSort getSort}.
+     */
+    public final static int EXCEPTION_PARAMETER = 0x42;
+
+    /**
+     * The sort of type references that target the type declared in an
+     * 'instanceof' instruction. See {@link #getSort getSort}.
+     */
+    public final static int INSTANCEOF = 0x43;
+
+    /**
+     * The sort of type references that target the type of the object created by
+     * a 'new' instruction. See {@link #getSort getSort}.
+     */
+    public final static int NEW = 0x44;
+
+    /**
+     * The sort of type references that target the receiver type of a
+     * constructor reference. See {@link #getSort getSort}.
+     */
+    public final static int CONSTRUCTOR_REFERENCE = 0x45;
+
+    /**
+     * The sort of type references that target the receiver type of a method
+     * reference. See {@link #getSort getSort}.
+     */
+    public final static int METHOD_REFERENCE = 0x46;
+
+    /**
+     * The sort of type references that target the type declared in an explicit
+     * or implicit cast instruction. See {@link #getSort getSort}.
+     */
+    public final static int CAST = 0x47;
+
+    /**
+     * The sort of type references that target a type parameter of a generic
+     * constructor in a constructor call. See {@link #getSort getSort}.
+     */
+    public final static int CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT = 0x48;
+
+    /**
+     * The sort of type references that target a type parameter of a generic
+     * method in a method call. See {@link #getSort getSort}.
+     */
+    public final static int METHOD_INVOCATION_TYPE_ARGUMENT = 0x49;
+
+    /**
+     * The sort of type references that target a type parameter of a generic
+     * constructor in a constructor reference. See {@link #getSort getSort}.
+     */
+    public final static int CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT = 0x4A;
+
+    /**
+     * The sort of type references that target a type parameter of a generic
+     * method in a method reference. See {@link #getSort getSort}.
+     */
+    public final static int METHOD_REFERENCE_TYPE_ARGUMENT = 0x4B;
+
+    /**
+     * The type reference value in Java class file format.
+     */
+    private int value;
+
+    /**
+     * Creates a new TypeReference.
+     *
+     * @param typeRef
+     *            the int encoded value of the type reference, as received in a
+     *            visit method related to type annotations, like
+     *            visitTypeAnnotation.
+     */
+    public TypeReference(int typeRef) {
+        this.value = typeRef;
+    }
+
+    /**
+     * Returns a type reference of the given sort.
+     *
+     * @param sort
+     *            {@link #FIELD FIELD}, {@link #METHOD_RETURN METHOD_RETURN},
+     *            {@link #METHOD_RECEIVER METHOD_RECEIVER},
+     *            {@link #LOCAL_VARIABLE LOCAL_VARIABLE},
+     *            {@link #RESOURCE_VARIABLE RESOURCE_VARIABLE},
+     *            {@link #INSTANCEOF INSTANCEOF}, {@link #NEW NEW},
+     *            {@link #CONSTRUCTOR_REFERENCE CONSTRUCTOR_REFERENCE}, or
+     *            {@link #METHOD_REFERENCE METHOD_REFERENCE}.
+     * @return a type reference of the given sort.
+     */
+    public static TypeReference newTypeReference(int sort) {
+        return new TypeReference(sort << 24);
+    }
+
+    /**
+     * Returns a reference to a type parameter of a generic class or method.
+     *
+     * @param sort
+     *            {@link #CLASS_TYPE_PARAMETER CLASS_TYPE_PARAMETER} or
+     *            {@link #METHOD_TYPE_PARAMETER METHOD_TYPE_PARAMETER}.
+     * @param paramIndex
+     *            the type parameter index.
+     * @return a reference to the given generic class or method type parameter.
+     */
+    public static TypeReference newTypeParameterReference(int sort,
+            int paramIndex) {
+        return new TypeReference((sort << 24) | (paramIndex << 16));
+    }
+
+    /**
+     * Returns a reference to a type parameter bound of a generic class or
+     * method.
+     *
+     * @param sort
+     *            {@link #CLASS_TYPE_PARAMETER CLASS_TYPE_PARAMETER} or
+     *            {@link #METHOD_TYPE_PARAMETER METHOD_TYPE_PARAMETER}.
+     * @param paramIndex
+     *            the type parameter index.
+     * @param boundIndex
+     *            the type bound index within the above type parameters.
+     * @return a reference to the given generic class or method type parameter
+     *         bound.
+     */
+    public static TypeReference newTypeParameterBoundReference(int sort,
+            int paramIndex, int boundIndex) {
+        return new TypeReference((sort << 24) | (paramIndex << 16)
+                | (boundIndex << 8));
+    }
+
+    /**
+     * Returns a reference to the super class or to an interface of the
+     * 'implements' clause of a class.
+     *
+     * @param itfIndex
+     *            the index of an interface in the 'implements' clause of a
+     *            class, or -1 to reference the super class of the class.
+     * @return a reference to the given super type of a class.
+     */
+    public static TypeReference newSuperTypeReference(int itfIndex) {
+        itfIndex &= 0xFFFF;
+        return new TypeReference((CLASS_EXTENDS << 24) | (itfIndex << 8));
+    }
+
+    /**
+     * Returns a reference to the type of a formal parameter of a method.
+     *
+     * @param paramIndex
+     *            the formal parameter index.
+     *
+     * @return a reference to the type of the given method formal parameter.
+     */
+    public static TypeReference newFormalParameterReference(int paramIndex) {
+        return new TypeReference((METHOD_FORMAL_PARAMETER << 24)
+                | (paramIndex << 16));
+    }
+
+    /**
+     * Returns a reference to the type of an exception, in a 'throws' clause of
+     * a method.
+     *
+     * @param exceptionIndex
+     *            the index of an exception in a 'throws' clause of a method.
+     *
+     * @return a reference to the type of the given exception.
+     */
+    public static TypeReference newExceptionReference(int exceptionIndex) {
+        return new TypeReference((THROWS << 24) | (exceptionIndex << 8));
+    }
+
+    /**
+     * Returns a reference to the type of the exception declared in a 'catch'
+     * clause of a method.
+     *
+     * @param tryCatchBlockIndex
+     *            the index of a try catch block (using the order in which they
+     *            are visited with visitTryCatchBlock).
+     *
+     * @return a reference to the type of the given exception.
+     */
+    public static TypeReference newTryCatchReference(int tryCatchBlockIndex) {
+        return new TypeReference((EXCEPTION_PARAMETER << 24)
+                | (tryCatchBlockIndex << 8));
+    }
+
+    /**
+     * Returns a reference to the type of a type argument in a constructor or
+     * method call or reference.
+     *
+     * @param sort
+     *            {@link #CAST CAST},
+     *            {@link #CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT
+     *            CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT},
+     *            {@link #METHOD_INVOCATION_TYPE_ARGUMENT
+     *            METHOD_INVOCATION_TYPE_ARGUMENT},
+     *            {@link #CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT
+     *            CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT}, or
+     *            {@link #METHOD_REFERENCE_TYPE_ARGUMENT
+     *            METHOD_REFERENCE_TYPE_ARGUMENT}.
+     * @param argIndex
+     *            the type argument index.
+     *
+     * @return a reference to the type of the given type argument.
+     */
+    public static TypeReference newTypeArgumentReference(int sort, int argIndex) {
+        return new TypeReference((sort << 24) | argIndex);
+    }
+
+    /**
+     * Returns the sort of this type reference.
+     *
+     * @return {@link #CLASS_TYPE_PARAMETER CLASS_TYPE_PARAMETER},
+     *         {@link #METHOD_TYPE_PARAMETER METHOD_TYPE_PARAMETER},
+     *         {@link #CLASS_EXTENDS CLASS_EXTENDS},
+     *         {@link #CLASS_TYPE_PARAMETER_BOUND CLASS_TYPE_PARAMETER_BOUND},
+     *         {@link #METHOD_TYPE_PARAMETER_BOUND METHOD_TYPE_PARAMETER_BOUND},
+     *         {@link #FIELD FIELD}, {@link #METHOD_RETURN METHOD_RETURN},
+     *         {@link #METHOD_RECEIVER METHOD_RECEIVER},
+     *         {@link #METHOD_FORMAL_PARAMETER METHOD_FORMAL_PARAMETER},
+     *         {@link #THROWS THROWS}, {@link #LOCAL_VARIABLE LOCAL_VARIABLE},
+     *         {@link #RESOURCE_VARIABLE RESOURCE_VARIABLE},
+     *         {@link #EXCEPTION_PARAMETER EXCEPTION_PARAMETER},
+     *         {@link #INSTANCEOF INSTANCEOF}, {@link #NEW NEW},
+     *         {@link #CONSTRUCTOR_REFERENCE CONSTRUCTOR_REFERENCE},
+     *         {@link #METHOD_REFERENCE METHOD_REFERENCE}, {@link #CAST CAST},
+     *         {@link #CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT
+     *         CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT},
+     *         {@link #METHOD_INVOCATION_TYPE_ARGUMENT
+     *         METHOD_INVOCATION_TYPE_ARGUMENT},
+     *         {@link #CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT
+     *         CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT}, or
+     *         {@link #METHOD_REFERENCE_TYPE_ARGUMENT
+     *         METHOD_REFERENCE_TYPE_ARGUMENT}.
+     */
+    public int getSort() {
+        return value >>> 24;
+    }
+
+    /**
+     * Returns the index of the type parameter referenced by this type
+     * reference. This method must only be used for type references whose sort
+     * is {@link #CLASS_TYPE_PARAMETER CLASS_TYPE_PARAMETER},
+     * {@link #METHOD_TYPE_PARAMETER METHOD_TYPE_PARAMETER},
+     * {@link #CLASS_TYPE_PARAMETER_BOUND CLASS_TYPE_PARAMETER_BOUND} or
+     * {@link #METHOD_TYPE_PARAMETER_BOUND METHOD_TYPE_PARAMETER_BOUND}.
+     *
+     * @return a type parameter index.
+     */
+    public int getTypeParameterIndex() {
+        return (value & 0x00FF0000) >> 16;
+    }
+
+    /**
+     * Returns the index of the type parameter bound, within the type parameter
+     * {@link #getTypeParameterIndex}, referenced by this type reference. This
+     * method must only be used for type references whose sort is
+     * {@link #CLASS_TYPE_PARAMETER_BOUND CLASS_TYPE_PARAMETER_BOUND} or
+     * {@link #METHOD_TYPE_PARAMETER_BOUND METHOD_TYPE_PARAMETER_BOUND}.
+     *
+     * @return a type parameter bound index.
+     */
+    public int getTypeParameterBoundIndex() {
+        return (value & 0x0000FF00) >> 8;
+    }
+
+    /**
+     * Returns the index of the "super type" of a class that is referenced by
+     * this type reference. This method must only be used for type references
+     * whose sort is {@link #CLASS_EXTENDS CLASS_EXTENDS}.
+     *
+     * @return the index of an interface in the 'implements' clause of a class,
+     *         or -1 if this type reference references the type of the super
+     *         class.
+     */
+    public int getSuperTypeIndex() {
+        return (short) ((value & 0x00FFFF00) >> 8);
+    }
+
+    /**
+     * Returns the index of the formal parameter whose type is referenced by
+     * this type reference. This method must only be used for type references
+     * whose sort is {@link #METHOD_FORMAL_PARAMETER METHOD_FORMAL_PARAMETER}.
+     *
+     * @return a formal parameter index.
+     */
+    public int getFormalParameterIndex() {
+        return (value & 0x00FF0000) >> 16;
+    }
+
+    /**
+     * Returns the index of the exception, in a 'throws' clause of a method,
+     * whose type is referenced by this type reference. This method must only be
+     * used for type references whose sort is {@link #THROWS THROWS}.
+     *
+     * @return the index of an exception in the 'throws' clause of a method.
+     */
+    public int getExceptionIndex() {
+        return (value & 0x00FFFF00) >> 8;
+    }
+
+    /**
+     * Returns the index of the try catch block (using the order in which they
+     * are visited with visitTryCatchBlock), whose 'catch' type is referenced by
+     * this type reference. This method must only be used for type references
+     * whose sort is {@link #EXCEPTION_PARAMETER EXCEPTION_PARAMETER} .
+     *
+     * @return the index of an exception in the 'throws' clause of a method.
+     */
+    public int getTryCatchBlockIndex() {
+        return (value & 0x00FFFF00) >> 8;
+    }
+
+    /**
+     * Returns the index of the type argument referenced by this type reference.
+     * This method must only be used for type references whose sort is
+     * {@link #CAST CAST}, {@link #CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT
+     * CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT},
+     * {@link #METHOD_INVOCATION_TYPE_ARGUMENT METHOD_INVOCATION_TYPE_ARGUMENT},
+     * {@link #CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT
+     * CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT}, or
+     * {@link #METHOD_REFERENCE_TYPE_ARGUMENT METHOD_REFERENCE_TYPE_ARGUMENT}.
+     *
+     * @return a type parameter index.
+     */
+    public int getTypeArgumentIndex() {
+        return value & 0xFF;
+    }
+
+    /**
+     * Returns the int encoded value of this type reference, suitable for use in
+     * visit methods related to type annotations, like visitTypeAnnotation.
+     *
+     * @return the int encoded value of this type reference.
+     */
+    public int getValue() {
+        return value;
+    }
+}

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

@@ -0,0 +1,27 @@
+need copy classes:
+
+AnnotationVisitor.java
+AnnotationWriter.java
+Attribute.java
+ByteVector.java
+ClassReader.java
+ClassVisitor.java
+ClassWriter.java
+Context.java
+CurrentFrame.java
+Edge.java
+FieldVisitor.java
+FieldWriter.java
+Frame.java
+Handle.java
+Handler.java
+Item.java
+Label.java
+MethodVisitor.java
+MethodWriter.java
+ModuleVisitor.java
+ModuleWriter.java
+Opcodes.java
+Type.java
+TypePath.java
+TypeReference.java

src/main/java/org/redkale/asm/package-info.java

@@ -0,0 +1,4 @@
+/**
+ * 本包下所有代码均是从/java.base/jdk/internal/org/objectweb/asm 拷贝过来的
+ */
+package org.redkale.asm;

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

@@ -35,6 +35,30 @@ public interface ApplicationListener {
     default void preStart(Application application) {
     }
 
+    /**
+     * Application 在运行start后调用
+     *
+     * @param application Application
+     */
+    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

@@ -7,13 +7,16 @@ package org.redkale.boot;
 
 import java.io.*;
 import java.lang.annotation.*;
-import java.lang.reflect.*;
+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;
 
@@ -30,12 +33,14 @@ public final class ClassFilter<T> {
 
     private static final Logger logger = Logger.getLogger(ClassFilter.class.getName()); //日志对象
 
-    private static final boolean finer = logger.isLoggable(Level.FINER); //日志级别
+    private static final boolean finest = logger.isLoggable(Level.FINEST); //日志级别
 
     private final Set<FilterEntry<T>> entrys = new HashSet<>(); //符合条件的结果
 
     private final Set<FilterEntry<T>> expectEntrys = new HashSet<>(); //准备符合条件的结果
 
+    private Predicate<String> expectPredicate;
+
     private boolean refused; //是否拒绝所有数据,设置true，则其他规则失效,都是拒绝.
 
     private Class superClass; //符合的父类型。不为空时，扫描结果的class必须是superClass的子类
@@ -60,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;
@@ -72,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) {
+    public static ClassFilter create(RedkaleClassLoader classLoader, Class[] excludeSuperClasses, String includeregs, String excluderegs, Set<String> includeValues, Set<String> excludeValues) {
-        ClassFilter filter = new ClassFilter(null, null, null, excludeSuperClasses);
+        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);
@@ -99,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<>();
+        List<FilterEntry<T>> list = new ArrayList<>();
-        set.addAll(entrys);
+        list.addAll(entrys);
-        if (ors != null) ors.forEach(f -> set.addAll(f.getFilterEntrys()));
+        if (ors != null) ors.forEach(f -> list.addAll(f.getFilterEntrys()));
-        if (ands != null) ands.forEach(f -> set.addAll(f.getFilterEntrys()));
+        if (ands != null) ands.forEach(f -> list.addAll(f.getFilterEntrys()));
-        return set;
+        Collections.sort(list);
+        return new LinkedHashSet<>(list);
     }
 
     /**
@@ -112,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<>();
+        List<FilterEntry<T>> list = new ArrayList<>();
-        set.addAll(expectEntrys);
+        list.addAll(expectEntrys);
-        if (ors != null) ors.forEach(f -> set.addAll(f.getFilterExpectEntrys()));
+        if (ors != null) ors.forEach(f -> list.addAll(f.getFilterExpectEntrys()));
-        if (ands != null) ands.forEach(f -> set.addAll(f.getFilterExpectEntrys()));
+        if (ands != null) ands.forEach(f -> list.addAll(f.getFilterExpectEntrys()));
-        return set;
+        Collections.sort(list);
+        return new LinkedHashSet<>(list);
     }
 
     /**
@@ -125,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;
@@ -136,10 +143,11 @@ public final class ClassFilter<T> {
      *
      * @param property  AnyValue
      * @param clazzname String
+     * @param url       URL
      */
     @SuppressWarnings("unchecked")
-    public final void filter(AnyValue property, String clazzname) {
+    public final void filter(AnyValue property, String clazzname, URL url) {
-        filter(property, clazzname, true);
+        filter(property, clazzname, true, url);
     }
 
     /**
@@ -150,6 +158,18 @@ public final class ClassFilter<T> {
      * @param autoscan  为true表示自动扫描的， false表示显著调用filter， AutoLoad的注解将被忽略
      */
     public final void filter(AnyValue property, String clazzname, boolean autoscan) {
+        filter(property, clazzname, autoscan, null);
+    }
+
+    /**
+     * 过滤指定的class
+     *
+     * @param property  application.xml中对应class节点下的property属性项
+     * @param clazzname class名称
+     * @param autoscan  为true表示自动扫描的， false表示显著调用filter， AutoLoad的注解将被忽略
+     * @param url       URL
+     */
+    public final void filter(AnyValue property, String clazzname, boolean autoscan, URL url) {
         boolean r = accept0(property, clazzname);
         ClassFilter cf = r ? this : null;
         if (r && ands != null) {
@@ -159,13 +179,14 @@ public final class ClassFilter<T> {
         }
         if (!r && ors != null) {
             for (ClassFilter filter : ors) {
-                if (filter.accept(property, clazzname)) {
+                if (filter.accept(filter.conf, clazzname)) {
                     cf = filter;
+                    property = cf.conf;
                     break;
                 }
             }
         }
-        if (cf == null || clazzname.startsWith("sun.")) return;
+        if (cf == null || clazzname.startsWith("sun.") || clazzname.contains("module-info")) return;
         try {
             Class clazz = classLoader.loadClass(clazzname);
             if (!cf.accept(property, clazz, autoscan)) return;
@@ -173,25 +194,28 @@ public final class ClassFilter<T> {
                 if (property == null) {
                     property = cf.conf;
                 } else if (property instanceof DefaultAnyValue) {
-                    ((DefaultAnyValue) property).addAll(cf.conf);
+                    ((DefaultAnyValue) property).addAllStringSet(cf.conf);
                 } else {
                     DefaultAnyValue dav = new DefaultAnyValue();
-                    dav.addAll(property);
+                    dav.addAllStringSet(property);
-                    dav.addAll(cf.conf);
+                    dav.addAllStringSet(cf.conf);
                     property = dav;
                 }
             }
 
             AutoLoad auto = (AutoLoad) clazz.getAnnotation(AutoLoad.class);
-            if (autoscan && auto != null && !auto.value()) { //自动扫描且被标记为@AutoLoad(false)的
+            if ((expectPredicate != null && expectPredicate.test(clazzname)) || (autoscan && auto != null && !auto.value())) { //自动扫描且被标记为@AutoLoad(false)的
                 expectEntrys.add(new FilterEntry(clazz, autoscan, true, property));
             } else {
                 entrys.add(new FilterEntry(clazz, autoscan, false, property));
             }
         } catch (Throwable cfe) {
-            if (finer && !clazzname.startsWith("sun.") && !clazzname.startsWith("javax.")
+            if (finest && !clazzname.startsWith("sun.") && !clazzname.startsWith("javax.")
-                && !clazzname.startsWith("com.sun.") && !clazzname.startsWith("jdk.")) {
+                && !clazzname.startsWith("com.sun.") && !clazzname.startsWith("jdk.") && !clazzname.startsWith("META-INF")
-                logger.log(Level.FINEST, ClassFilter.class.getSimpleName() + " filter error", cfe);
+                && !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);
             }
         }
     }
@@ -224,7 +248,7 @@ public final class ClassFilter<T> {
         }
         if (!r && ors != null) {
             for (ClassFilter filter : ors) {
-                if (filter.accept(property, classname)) return true;
+                if (filter.accept(filter.conf, classname)) return true;
             }
         }
         return r;
@@ -333,6 +357,14 @@ public final class ClassFilter<T> {
         this.refused = refused;
     }
 
+    public Predicate<String> getExpectPredicate() {
+        return expectPredicate;
+    }
+
+    public void setExpectPredicate(Predicate<String> predicate) {
+        this.expectPredicate = predicate;
+    }
+
     public Set<String> getPrivilegeIncludes() {
         return privilegeIncludes;
     }
@@ -347,6 +379,7 @@ public final class ClassFilter<T> {
 
     public void setPrivilegeExcludes(Set<String> privilegeExcludes) {
         this.privilegeExcludes = privilegeExcludes == null || privilegeExcludes.isEmpty() ? null : privilegeExcludes;
+
     }
 
     /**
@@ -354,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<>();
 
@@ -379,17 +412,25 @@ public final class ClassFilter<T> {
                 str = str.trim();
                 if (str.endsWith(";")) str = str.substring(0, str.length() - 1);
             }
-            if (str != null) groups.addAll(Arrays.asList(str.split(";")));
+            if (str != null) this.groups.addAll(Arrays.asList(str.split(";")));
             this.property = property;
             this.autoload = autoload;
             this.expect = expect;
             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()
-                + ", type=" + this.type.getSimpleName() + ", name=" + name + ", groups=" + groups + "]";
+                + ", type=" + this.type.getSimpleName() + ", name=" + name + ", groups=" + this.groups + "]";
         }
 
         @Override
@@ -416,6 +457,10 @@ public final class ClassFilter<T> {
             return property;
         }
 
+        public boolean containsGroup(String group) {
+            return groups != null && groups.contains(group);
+        }
+
         public boolean isEmptyGroups() {
             return groups == null || groups.isEmpty();
         }
@@ -431,6 +476,7 @@ public final class ClassFilter<T> {
         public boolean isExpect() {
             return expect;
         }
+
     }
 
     /**
@@ -450,24 +496,24 @@ 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 {
+        public static void load(final File excludeFile, RedkaleClassLoader loader, final String[] excludeRegs, final ClassFilter... filters) throws IOException {
-            RedkaleClassLoader loader = (RedkaleClassLoader) Thread.currentThread().getContextClassLoader();
             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()) {
-                            skip = false;
+                            skip = true;
                             break;
                         }
                     }
@@ -486,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('/', '.');
@@ -494,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;
@@ -502,7 +549,7 @@ public final class ClassFilter<T> {
                                 classes.add(classname);
                                 if (debug) debugstr.append(classname).append("\r\n");
                                 for (final ClassFilter filter : filters) {
-                                    if (filter != null) filter.filter(null, classname);
+                                    if (filter != null) filter.filter(null, classname, url);
                                 }
                             }
                         }
@@ -511,7 +558,7 @@ public final class ClassFilter<T> {
                 } else {
                     for (String classname : classes) {
                         for (final ClassFilter filter : filters) {
-                            if (filter != null) filter.filter(null, classname);
+                            if (filter != null) filter.filter(null, classname, url);
                         }
                     }
                 }
@@ -520,24 +567,34 @@ public final class ClassFilter<T> {
                 Set<String> classes = cache.get(url);
                 if (classes == null) {
                     classes = new LinkedHashSet<>();
-                    files.clear();
+                    final Set<String> cs = classes;
-                    File root = new File(url.getFile());
+                    if (url == RedkaleClassLoader.URL_NONE) loader.forEachCacheClass(v -> cs.add(v));
-                    String rootpath = root.getPath();
+                    if (cs.isEmpty()) {
-                    loadClassFiles(excludeFile, root, files);
+                        files.clear();
-                    for (File f : files) {
+                        File root = new File(url.getFile());
-                        String classname = f.getPath().substring(rootpath.length() + 1, f.getPath().length() - 6).replace(File.separatorChar, '.');
+                        String rootpath = root.getPath();
-                        if (classname.startsWith("javax.") || classname.startsWith("com.sun.")) continue;
+                        loadClassFiles(excludeFile, root, files);
-                        classes.add(classname);
+                        for (File f : files) {
-                        if (debug) debugstr.append(classname).append("\r\n");
+                            String classname = f.getPath().substring(rootpath.length() + 1, f.getPath().length() - 6).replace(File.separatorChar, '.');
-                        for (final ClassFilter filter : filters) {
+                            if (classname.startsWith("javax.") || classname.startsWith("com.sun.")) continue;
-                            if (filter != null) filter.filter(null, classname);
+                            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);
                 } else {
                     for (String classname : classes) {
                         for (final ClassFilter filter : filters) {
-                            if (filter != null) filter.filter(null, classname);
+                            if (filter != null) filter.filter(null, classname, url);
                         }
                     }
                 }
@@ -550,7 +607,9 @@ public final class ClassFilter<T> {
                 files.add(root);
             } else if (root.isDirectory()) {
                 if (exclude != null && exclude.equals(root)) return;
-                for (File f : root.listFiles()) {
+                File[] lfs = root.listFiles();
+                if (lfs == null) throw new RuntimeException("File(" + root + ") cannot listFiles()");
+                for (File f : lfs) {
                     loadClassFiles(exclude, f, files);
                 }
             }

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,15 +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.*;
 
 /**
  * 自定义的日志输出类
@@ -23,12 +26,17 @@ import java.util.logging.Formatter;
  * @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() {
@@ -36,28 +44,71 @@ 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 record) {
+        public String format(LogRecord log) {
+            if (log.getThrown() == null && log.getMessage() != null && log.getMessage().startsWith("------")) {
+                return formatMessage(log) + "\r\n";
+            }
             String source;
-            if (record.getSourceClassName() != null) {
+            if (log.getSourceClassName() != null) {
-                source = record.getSourceClassName();
+                source = log.getSourceClassName();
-                if (record.getSourceMethodName() != null) {
+                if (log.getSourceMethodName() != null) {
-                    source += " " + record.getSourceMethodName();
+                    source += " " + log.getSourceMethodName();
                 }
             } else {
-                source = record.getLoggerName();
+                source = log.getLoggerName();
             }
-            String message = formatMessage(record);
+            String message = formatMessage(log);
             String throwable = "";
-            if (record.getThrown() != null) {
+            if (log.getThrown() != null) {
                 StringWriter sw = new StringWriter();
                 PrintWriter pw = new PrintWriter(sw) {
                     @Override
@@ -66,26 +117,46 @@ public class LogFileHandler extends Handler {
                     }
                 };
                 pw.println();
-                record.getThrown().printStackTrace(pw);
+                log.getThrown().printStackTrace(pw);
                 pw.close();
                 throwable = sw.toString();
             }
-            return String.format(format,
+            return String.format(FORMATTER_FORMAT,
                 System.currentTimeMillis(),
                 source,
-                record.getLoggerName(),
+                log.getLoggerName(),
-                record.getLevel().getName(),
+                log.getLevel().getName(),
                 message,
                 throwable);
         }
-
     }
 
-    protected final LinkedBlockingQueue<LogRecord> records = new LinkedBlockingQueue();
+    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) {
+        }
+    }
 
-    private String pattern;
+    protected final LinkedBlockingQueue<LogRecord> logqueue = new LinkedBlockingQueue();
 
-    private String unusual; //不为null表示将 WARNING、SEVERE 级别的日志写入单独的文件中
+    protected String pattern;
+
+    protected String patternDateFormat; //需要时间格式化
+
+    protected String unusual; //不为null表示将 WARNING、SEVERE 级别的日志写入单独的文件中
+
+    protected String unusualDateFormat; //需要时间格式化
 
     private int limit;   //文件大小限制
 
@@ -97,7 +168,9 @@ public class LogFileHandler extends Handler {
 
     private long tomorrow;
 
-    private boolean append;
+    protected boolean append;
+
+    protected Pattern denyreg;
 
     private final AtomicLong loglength = new AtomicLong();
 
@@ -111,7 +184,7 @@ public class LogFileHandler extends Handler {
 
     private OutputStream logunusualstream;
 
-    public LogFileHandler() {
+    public LoggingFileHandler() {
         updateTomorrow();
         configure();
         open();
@@ -130,7 +203,7 @@ public class LogFileHandler extends Handler {
     }
 
     private void open() {
-        final String name = "Logging-" + getClass().getSimpleName() + "-Thread";
+        final String name = "Redkale-Logging-" + getClass().getSimpleName() + "-Thread";
         new Thread() {
             {
                 setName(name);
@@ -141,9 +214,9 @@ public class LogFileHandler extends Handler {
             public void run() {
                 while (true) {
                     try {
-                        LogRecord record = records.take();
+                        LogRecord log = logqueue.take();
                         final boolean bigger = (limit > 0 && limit <= loglength.get());
-                        final boolean changeday = tomorrow <= record.getMillis();
+                        final boolean changeday = tomorrow <= log.getMillis();
                         if (bigger || changeday) {
                             updateTomorrow();
                             if (logstream != null) {
@@ -154,6 +227,8 @@ public class LogFileHandler extends Handler {
                                         if (greater.exists()) Files.move(greater.toPath(), new File(logfile.getPath() + "." + (i + 1)).toPath(), REPLACE_EXISTING, ATOMIC_MOVE);
                                     }
                                     Files.move(logfile.toPath(), new File(logfile.getPath() + ".1").toPath(), REPLACE_EXISTING, ATOMIC_MOVE);
+                                } else {
+                                    if (logfile.exists() && logfile.length() < 1) logfile.delete();
                                 }
                                 logstream = null;
                             }
@@ -166,32 +241,32 @@ public class LogFileHandler extends Handler {
                                     if (greater.exists()) Files.move(greater.toPath(), new File(logunusualfile.getPath() + "." + (i + 1)).toPath(), REPLACE_EXISTING, ATOMIC_MOVE);
                                 }
                                 Files.move(logunusualfile.toPath(), new File(logunusualfile.getPath() + ".1").toPath(), REPLACE_EXISTING, ATOMIC_MOVE);
+                            } else {
+                                if (logunusualfile.exists() && logunusualfile.length() < 1) logunusualfile.delete();
                             }
                             logunusualstream = null;
                         }
                         if (logstream == null) {
                             logindex.incrementAndGet();
-                            java.time.LocalDate date = LocalDate.now();
+                            logfile = new File(patternDateFormat == null ? pattern : Utility.formatTime(patternDateFormat, -1, System.currentTimeMillis()));
-                            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.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(unusualDateFormat == null ? unusual : Utility.formatTime(unusualDateFormat, -1, System.currentTimeMillis()));
-                            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.getParentFile().mkdirs();
                             logunusuallength.set(logunusualfile.length());
                             logunusualstream = new FileOutputStream(logunusualfile, append);
                         }
                         //----------------------写日志-------------------------
-                        String message = getFormatter().format(record);
+                        String message = getFormatter().format(log);
                         String encoding = getEncoding();
                         byte[] bytes = encoding == null ? message.getBytes() : message.getBytes(encoding);
                         logstream.write(bytes);
                         loglength.addAndGet(bytes.length);
-                        if (unusual != null && (record.getLevel() == Level.WARNING || record.getLevel() == Level.SEVERE)) {
+                        if (unusual != null && (log.getLevel() == Level.WARNING || log.getLevel() == Level.SEVERE)) {
                             logunusualstream.write(bytes);
                             logunusuallength.addAndGet(bytes.length);
                         }
@@ -211,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) {
@@ -223,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('/');
@@ -232,9 +311,27 @@ 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) this.limit = Math.abs(Integer.decode(limitstr));
+            if (limitstr != null) {
+                limitstr = limitstr.toUpperCase();
+                boolean g = limitstr.indexOf('G') > 0;
+                boolean m = limitstr.indexOf('M') > 0;
+                boolean k = limitstr.indexOf('K') > 0;
+                int ls = Math.abs(Integer.decode(limitstr.replace("G", "").replace("M", "").replace("K", "").replace("B", "")));
+                if (g) {
+                    ls *= 1024 * 1024 * 1024;
+                } else if (m) {
+                    ls *= 1024 * 1024;
+                } else if (k) {
+                    ls *= 1024;
+                }
+                this.limit = ls;
+            }
         } catch (Exception e) {
         }
         String countstr = manager.getProperty(cname + ".count");
@@ -259,7 +356,8 @@ public class LogFileHandler extends Handler {
         try {
             if (filterstr != null) {
                 Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(filterstr);
-                setFilter((Filter) clz.newInstance());
+                RedkaleClassLoader.putReflectionDeclaredConstructors(clz, clz.getName());
+                setFilter((Filter) clz.getDeclaredConstructor().newInstance());
             }
         } catch (Exception e) {
         }
@@ -267,7 +365,8 @@ public class LogFileHandler extends Handler {
         try {
             if (formatterstr != null) {
                 Class<?> clz = ClassLoader.getSystemClassLoader().loadClass(formatterstr);
-                setFormatter((Formatter) clz.newInstance());
+                RedkaleClassLoader.putReflectionDeclaredConstructors(clz, clz.getName());
+                setFormatter((Formatter) clz.getDeclaredConstructor().newInstance());
             }
         } catch (Exception e) {
         }
@@ -278,23 +377,46 @@ public class LogFileHandler extends Handler {
             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 record) {
+    public void publish(LogRecord log) {
-        final String sourceClassName = record.getSourceClassName();
+        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;
-                record.setSourceClassName('[' + Thread.currentThread().getName() + "] " + ses[i].getClassName());
+                log.setSourceClassName('[' + Thread.currentThread().getName() + "] " + ses[i].getClassName());
-                record.setSourceMethodName(ses[i].getMethodName());
+                log.setSourceMethodName(ses[i].getMethodName());
                 break;
             }
         } else {
-            record.setSourceClassName('[' + Thread.currentThread().getName() + "] " + sourceClassName);
+            log.setSourceClassName('[' + Thread.currentThread().getName() + "] " + sourceClassName);
         }
-        records.offer(record);
+        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);
     }
 
     @Override

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

@@ -1,341 +1,446 @@
-/*
+/*
- * To change this license header, choose License Headers in Project Properties.
+ * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
+ * To change this template file, choose Tools | Templates
- * and open the template in the editor.
+ * and open the template in the editor.
- */
+ */
-package org.redkale.boot;
+package org.redkale.boot;
-
+
-import java.lang.annotation.Annotation;
+import java.lang.annotation.Annotation;
-import java.lang.reflect.*;
+import java.lang.reflect.*;
-import java.net.*;
+import java.net.*;
-import java.util.*;
+import java.util.*;
-import java.util.logging.Level;
+import java.util.concurrent.CountDownLatch;
-import javax.annotation.*;
+import java.util.logging.Level;
-import static org.redkale.boot.Application.RESNAME_SNCP_ADDR;
+import java.util.stream.Stream;
-import org.redkale.boot.ClassFilter.FilterEntry;
+import javax.annotation.*;
-import org.redkale.net.*;
+import static org.redkale.boot.Application.RESNAME_SNCP_ADDR;
-import org.redkale.net.http.*;
+import org.redkale.boot.ClassFilter.FilterEntry;
-import org.redkale.net.sncp.Sncp;
+import org.redkale.cluster.ClusterAgent;
-import org.redkale.service.*;
+import org.redkale.mq.MessageAgent;
-import org.redkale.util.AnyValue.DefaultAnyValue;
+import org.redkale.net.*;
-import org.redkale.util.*;
+import org.redkale.net.http.*;
-import org.redkale.watch.*;
+import org.redkale.net.sncp.Sncp;
-
+import org.redkale.service.*;
-/**
+import org.redkale.util.AnyValue.DefaultAnyValue;
- * HTTP Server节点的配置Server
+import org.redkale.util.*;
- *
+import org.redkale.watch.*;
- * <p>
+
- * 详情见: https://redkale.org
+/**
- *
+ * HTTP Server节点的配置Server
- * @author zhangjx
+ *
- */
+ * <p>
-@NodeProtocol({"HTTP"})
+ * 详情见: https://redkale.org
-public class NodeHttpServer extends NodeServer {
+ *
-
+ * @author zhangjx
-    protected final boolean rest; //是否加载REST服务， 为true加载rest节点信息并将所有可REST化的Service生成RestServlet
+ */
-
+@NodeProtocol("HTTP")
-    protected final HttpServer httpServer;
+public class NodeHttpServer extends NodeServer {
-
+
-    public NodeHttpServer(Application application, AnyValue serconf) {
+    protected final boolean rest; //是否加载REST服务， 为true加载rest节点信息并将所有可REST化的Service生成RestServlet
-        super(application, createServer(application, serconf));
+
-        this.httpServer = (HttpServer) server;
+    protected final HttpServer httpServer;
-        this.rest = serconf == null ? false : serconf.getAnyValue("rest") != null;
+
-    }
+    public NodeHttpServer(Application application, AnyValue serconf) {
-
+        super(application, createServer(application, serconf));
-    private static Server createServer(Application application, AnyValue serconf) {
+        this.httpServer = (HttpServer) server;
-        return new HttpServer(application.getStartTime());
+        this.rest = serconf == null ? false : serconf.getAnyValue("rest") != null;
-    }
+    }
-
+
-    public HttpServer getHttpServer() {
+    private static Server createServer(Application application, AnyValue serconf) {
-        return httpServer;
+        return new HttpServer(application, application.getStartTime(), application.getResourceFactory().createChild());
-    }
+    }
-
+
-    @Override
+    public HttpServer getHttpServer() {
-    public InetSocketAddress getSocketAddress() {
+        return httpServer;
-        return httpServer == null ? null : httpServer.getSocketAddress();
+    }
-    }
+
-
+    @Override
-    @Override
+    public InetSocketAddress getSocketAddress() {
-    protected ClassFilter<Service> createServiceClassFilter() {
+        return httpServer == null ? null : httpServer.getSocketAddress();
-        return createClassFilter(this.sncpGroup, null, Service.class, new Class[]{org.redkale.watch.WatchService.class}, Annotation.class, "services", "service");
+    }
-    }
+
-
+    @Override
-    @Override
+    @SuppressWarnings("unchecked")
-    protected ClassFilter<Filter> createFilterClassFilter() {
+    protected ClassFilter<Service> createServiceClassFilter() {
-        return createClassFilter(null, null, HttpFilter.class, new Class[]{WatchFilter.class}, null, "filters", "filter");
+        return createClassFilter(this.sncpGroup, null, Service.class, new Class[]{org.redkale.watch.WatchService.class}, Annotation.class, "services", "service");
-    }
+    }
-
+
-    @Override
+    @Override
-    protected ClassFilter<Servlet> createServletClassFilter() {
+    @SuppressWarnings("unchecked")
-        return createClassFilter(null, WebServlet.class, HttpServlet.class, new Class[]{WatchServlet.class}, null, "servlets", "servlet");
+    protected ClassFilter<Filter> createFilterClassFilter() {
-    }
+        return createClassFilter(null, null, HttpFilter.class, new Class[]{WatchFilter.class}, null, "filters", "filter");
-
+    }
-    @Override
+
-    protected ClassFilter createOtherClassFilter() {
+    @Override
-        return createClassFilter(null, RestWebSocket.class, WebSocket.class, null, null, "rest", "websocket");
+    @SuppressWarnings("unchecked")
-    }
+    protected ClassFilter<Servlet> createServletClassFilter() {
-
+        return createClassFilter(null, WebServlet.class, HttpServlet.class, new Class[]{WatchServlet.class}, null, "servlets", "servlet");
-    @Override
+    }
-    protected void loadService(ClassFilter<? extends Service> serviceFilter, ClassFilter otherFilter) throws Exception {
+
-        super.loadService(serviceFilter, otherFilter);
+    @Override
-        initWebSocketService();
+    protected ClassFilter createOtherClassFilter() {
-    }
+        return createClassFilter(null, RestWebSocket.class, WebSocket.class, null, null, "rest", "websocket");
-
+    }
-    @Override
+
-    protected void loadFilter(ClassFilter<? extends Filter> filterFilter, ClassFilter otherFilter) throws Exception {
+    @Override
-        if (httpServer != null) loadHttpFilter(this.serverConf.getAnyValue("filters"), filterFilter);
+    protected void loadService(ClassFilter<? extends Service> serviceFilter, ClassFilter otherFilter) throws Exception {
-    }
+        super.loadService(serviceFilter, otherFilter);
-
+        initWebSocketService();
-    @Override
+    }
-    protected void loadServlet(ClassFilter<? extends Servlet> servletFilter, ClassFilter otherFilter) throws Exception {
+
-        if (httpServer != null) loadHttpServlet(servletFilter, otherFilter);
+    @Override
-    }
+    protected void loadFilter(ClassFilter<? extends Filter> filterFilter, ClassFilter otherFilter) throws Exception {
-
+        if (httpServer != null) loadHttpFilter(filterFilter);
-    private void initWebSocketService() {
+    }
-        final NodeServer self = this;
+
-        final ResourceFactory regFactory = application.getResourceFactory();
+    @Override
-        resourceFactory.register((ResourceFactory rf, final Object src, final String resourceName, Field field, Object attachment) -> { //主要用于单点的服务
+    @SuppressWarnings("unchecked")
-            try {
+    protected void loadServlet(ClassFilter<? extends Servlet> servletFilter, ClassFilter otherFilter) throws Exception {
-                if (field.getAnnotation(Resource.class) == null) return;
+        if (httpServer != null) loadHttpServlet(servletFilter, otherFilter);
-                if (!(src instanceof WebSocketServlet)) return;
+    }
-                ResourceFactory.ResourceLoader loader = null;
+
-                ResourceFactory sncpResFactory = null;
+    private void initWebSocketService() {
-                for (NodeServer ns : application.servers) {
+        final NodeServer self = this;
-                    if (!ns.isSNCP()) continue;
+        final ResourceFactory regFactory = application.getResourceFactory();
-                    sncpResFactory = ns.resourceFactory;
+        resourceFactory.register((ResourceFactory rf, String srcResourceName, final Object srcObj, final String resourceName, Field field, Object attachment) -> { //主要用于单点的服务
-                    loader = sncpResFactory.findLoader(WebSocketNode.class, field);
+            try {
-                    if (loader != null) break;
+                if (field.getAnnotation(Resource.class) == null) return;
-                }
+                if (!(srcObj instanceof WebSocketServlet)) return;
-                if (loader != null) loader.load(sncpResFactory, src, resourceName, field, attachment);
+                ResourceTypeLoader loader = null;
-                synchronized (regFactory) {
+                ResourceFactory sncpResFactory = null;
-                    Service nodeService = (Service) rf.find(resourceName, WebSocketNode.class);
+                for (NodeServer ns : application.servers) {
-                    if (sncpResFactory != null && resourceFactory.find(RESNAME_SNCP_ADDR, String.class) == null) {
+                    if (!ns.isSNCP()) continue;
-                        resourceFactory.register(RESNAME_SNCP_ADDR, InetSocketAddress.class, sncpResFactory.find(RESNAME_SNCP_ADDR, InetSocketAddress.class));
+                    sncpResFactory = ns.resourceFactory;
-                        resourceFactory.register(RESNAME_SNCP_ADDR, SocketAddress.class, sncpResFactory.find(RESNAME_SNCP_ADDR, SocketAddress.class));
+                    loader = sncpResFactory.findTypeLoader(WebSocketNode.class, field);
-                        resourceFactory.register(RESNAME_SNCP_ADDR, String.class, sncpResFactory.find(RESNAME_SNCP_ADDR, String.class));
+                    if (loader != null) break;
-                    }
+                }
-                    if (nodeService == null) {
+                if (loader != null) loader.load(sncpResFactory, srcResourceName, srcObj, resourceName, field, attachment);
-                        nodeService = Sncp.createLocalService(serverClassLoader, resourceName, WebSocketNodeService.class, application.getResourceFactory(), application.getSncpTransportFactory(), (InetSocketAddress) null, (Set<String>) null, (AnyValue) null);
+                synchronized (regFactory) {
-                        regFactory.register(resourceName, WebSocketNode.class, nodeService);
+                    Service nodeService = (Service) rf.find(resourceName, WebSocketNode.class);
-                    }
+                    if (sncpResFactory != null && resourceFactory.find(RESNAME_SNCP_ADDR, String.class) == null) {
-                    resourceFactory.inject(nodeService, self);
+                        resourceFactory.register(RESNAME_SNCP_ADDR, InetSocketAddress.class, sncpResFactory.find(RESNAME_SNCP_ADDR, InetSocketAddress.class));
-                    logger.fine("[" + Thread.currentThread().getName() + "] Load Service " + nodeService);
+                        resourceFactory.register(RESNAME_SNCP_ADDR, SocketAddress.class, sncpResFactory.find(RESNAME_SNCP_ADDR, SocketAddress.class));
-                    field.set(src, nodeService);
+                        resourceFactory.register(RESNAME_SNCP_ADDR, String.class, sncpResFactory.find(RESNAME_SNCP_ADDR, String.class));
-                }
+                    }
-            } catch (Exception e) {
+                    if (nodeService == null) {
-                logger.log(Level.SEVERE, "WebSocketNode inject error", e);
+                        MessageAgent messageAgent = null;
-            }
+                        try {
-        }, WebSocketNode.class);
+                            Field c = WebSocketServlet.class.getDeclaredField("messageAgent");
-    }
+                            c.setAccessible(true);
-
+                            messageAgent = (MessageAgent) c.get(srcObj);
-    @SuppressWarnings("unchecked")
+                        } catch (Exception ex) {
-    protected void loadHttpFilter(final AnyValue filtersConf, final ClassFilter<? extends Filter> classFilter) throws Exception {
+                            logger.log(Level.WARNING, "WebSocketServlet getMessageAgent error", ex);
-        final StringBuilder sb = logger.isLoggable(Level.INFO) ? new StringBuilder() : null;
+                        }
-        final String threadName = "[" + Thread.currentThread().getName() + "] ";
+                        nodeService = Sncp.createLocalService(serverClassLoader, resourceName, org.redkale.net.http.WebSocketNodeService.class, messageAgent, application.getResourceFactory(), application.getSncpTransportFactory(), (InetSocketAddress) null, (Set<String>) null, (AnyValue) null);
-        List<FilterEntry<? extends Filter>> list = new ArrayList(classFilter.getFilterEntrys());
+                        regFactory.register(resourceName, WebSocketNode.class, nodeService);
-        for (FilterEntry<? extends Filter> en : list) {
+                    }
-            Class<HttpFilter> clazz = (Class<HttpFilter>) en.getType();
+                    resourceFactory.inject(resourceName, nodeService, self);
-            if (Modifier.isAbstract(clazz.getModifiers())) continue;
+                    field.set(srcObj, nodeService);
-            final HttpFilter filter = clazz.newInstance();
+                    logger.fine("[" + Thread.currentThread().getName() + "] Load Service " + nodeService);
-            resourceFactory.inject(filter, this);
+                }
-            DefaultAnyValue filterConf = (DefaultAnyValue) en.getProperty();
+            } catch (Exception e) {
-            this.httpServer.addHttpFilter(filter, filterConf);
+                logger.log(Level.SEVERE, "WebSocketNode inject error", e);
-            if (sb != null) sb.append(threadName).append(" Load ").append(clazz.getName()).append(LINE_SEPARATOR);
+            }
-        }
+        }, WebSocketNode.class);
-        if (sb != null && sb.length() > 0) logger.log(Level.INFO, sb.toString());
+    }
-    }
+
-
+    @SuppressWarnings("unchecked")
-    @SuppressWarnings("unchecked")
+    protected void loadHttpFilter(final ClassFilter<? extends Filter> classFilter) throws Exception {
-    protected void loadHttpServlet(final ClassFilter<? extends Servlet> servletFilter, ClassFilter<? extends WebSocket> webSocketFilter) throws Exception {
+        final StringBuilder sb = logger.isLoggable(Level.INFO) ? new StringBuilder() : null;
-        final AnyValue servletsConf = this.serverConf.getAnyValue("servlets");
+        final String localThreadName = "[" + Thread.currentThread().getName() + "] ";
-        final StringBuilder sb = logger.isLoggable(Level.INFO) ? new StringBuilder() : null;
+        List<FilterEntry<? extends Filter>> list = new ArrayList(classFilter.getFilterEntrys());
-        String prefix0 = servletsConf == null ? "" : servletsConf.getValue("path", "");
+        for (FilterEntry<? extends Filter> en : list) {
-        if (!prefix0.isEmpty() && prefix0.charAt(prefix0.length() - 1) == '/') prefix0 = prefix0.substring(0, prefix0.length() - 1);
+            Class<HttpFilter> clazz = (Class<HttpFilter>) en.getType();
-        if (!prefix0.isEmpty() && prefix0.charAt(0) != '/') prefix0 = '/' + prefix0;
+            if (Modifier.isAbstract(clazz.getModifiers())) continue;
-        final String prefix = prefix0;
+            RedkaleClassLoader.putReflectionDeclaredConstructors(clazz, clazz.getName());
-        final String threadName = "[" + Thread.currentThread().getName() + "] ";
+            final HttpFilter filter = clazz.getDeclaredConstructor().newInstance();
-        List<FilterEntry<? extends Servlet>> list = new ArrayList(servletFilter.getFilterEntrys());
+            resourceFactory.inject(filter, this);
-        list.sort((FilterEntry<? extends Servlet> o1, FilterEntry<? extends Servlet> o2) -> {  //必须保证WebSocketServlet优先加载， 因为要确保其他的HttpServlet可以注入本地模式的WebSocketNode
+            DefaultAnyValue filterConf = (DefaultAnyValue) en.getProperty();
-            boolean ws1 = WebSocketServlet.class.isAssignableFrom(o1.getType());
+            this.httpServer.addHttpFilter(filter, filterConf);
-            boolean ws2 = WebSocketServlet.class.isAssignableFrom(o2.getType());
+            if (sb != null) sb.append(localThreadName).append(" Load ").append(clazz.getName()).append(LINE_SEPARATOR);
-            if (ws1 == ws2) {
+        }
-                Priority p1 = o1.getType().getAnnotation(Priority.class);
+        if (sb != null && sb.length() > 0) logger.log(Level.INFO, sb.toString());
-                Priority p2 = o2.getType().getAnnotation(Priority.class);
+    }
-                int v = (p2 == null ? 0 : p2.value()) - (p1 == null ? 0 : p1.value());
+
-                return v == 0 ? o1.getType().getName().compareTo(o2.getType().getName()) : 0;
+    @SuppressWarnings("unchecked")
-            }
+    protected void loadHttpServlet(final ClassFilter<? extends Servlet> servletFilter, ClassFilter<? extends WebSocket> webSocketFilter) throws Exception {
-            return ws1 ? -1 : 1;
+        RedkaleClassLoader.putReflectionPublicClasses(HttpServlet.class.getName());
-        });
+        RedkaleClassLoader.putReflectionPublicClasses(HttpDispatcherServlet.class.getName());
-        final List<AbstractMap.SimpleEntry<String, String[]>> ss = sb == null ? null : new ArrayList<>();
+        RedkaleClassLoader.putReflectionDeclaredConstructors(HttpResourceServlet.class, HttpResourceServlet.class.getName());
-        for (FilterEntry<? extends Servlet> en : list) {
+        final AnyValue servletsConf = this.serverConf.getAnyValue("servlets");
-            Class<HttpServlet> clazz = (Class<HttpServlet>) en.getType();
+        final StringBuilder sb = logger.isLoggable(Level.INFO) ? new StringBuilder() : null;
-            if (Modifier.isAbstract(clazz.getModifiers())) continue;
+        String prefix0 = servletsConf == null ? "" : servletsConf.getValue("path", "");
-            WebServlet ws = clazz.getAnnotation(WebServlet.class);
+        if (!prefix0.isEmpty() && prefix0.charAt(prefix0.length() - 1) == '/') prefix0 = prefix0.substring(0, prefix0.length() - 1);
-            if (ws == null || ws.value().length == 0) continue;
+        if (!prefix0.isEmpty() && prefix0.charAt(0) != '/') prefix0 = '/' + prefix0;
-            final HttpServlet servlet = clazz.newInstance();
+        final String prefix = prefix0;
-            resourceFactory.inject(servlet, this);
+        final String localThreadName = "[" + Thread.currentThread().getName() + "] ";
-            final String[] mappings = ws.value();
+        List<FilterEntry<? extends Servlet>> list = new ArrayList(servletFilter.getFilterEntrys());
-            String pref = ws.repair() ? prefix : "";
+        list.sort((FilterEntry<? extends Servlet> o1, FilterEntry<? extends Servlet> o2) -> {  //必须保证WebSocketServlet优先加载， 因为要确保其他的HttpServlet可以注入本地模式的WebSocketNode
-            DefaultAnyValue servletConf = (DefaultAnyValue) en.getProperty();
+            boolean ws1 = WebSocketServlet.class.isAssignableFrom(o1.getType());
-            this.httpServer.addHttpServlet(servlet, pref, servletConf, mappings);
+            boolean ws2 = WebSocketServlet.class.isAssignableFrom(o2.getType());
-            if (ss != null) {
+            if (ws1 == ws2) {
-                for (int i = 0; i < mappings.length; i++) {
+                Priority p1 = o1.getType().getAnnotation(Priority.class);
-                    mappings[i] = pref + mappings[i];
+                Priority p2 = o2.getType().getAnnotation(Priority.class);
-                }
+                int v = (p2 == null ? 0 : p2.value()) - (p1 == null ? 0 : p1.value());
-                ss.add(new AbstractMap.SimpleEntry<>(clazz.getName(), mappings));
+                return v == 0 ? o1.getType().getName().compareTo(o2.getType().getName()) : 0;
-            }
+            }
-        }
+            return ws1 ? -1 : 1;
-        int max = 0;
+        });
-        if (ss != null && sb != null) {
+        final long starts = System.currentTimeMillis();
-            Collections.sort(ss, (AbstractMap.SimpleEntry<String, String[]> o1, AbstractMap.SimpleEntry<String, String[]> o2) -> o1.getKey().compareTo(o2.getKey()));
+        final List<AbstractMap.SimpleEntry<String, String[]>> ss = sb == null ? null : new ArrayList<>();
-            for (AbstractMap.SimpleEntry<String, String[]> as : ss) {
+        for (FilterEntry<? extends Servlet> en : list) {
-                if (as.getKey().length() > max) max = as.getKey().length();
+            Class<HttpServlet> clazz = (Class<HttpServlet>) en.getType();
-            }
+            if (Modifier.isAbstract(clazz.getModifiers())) continue;
-            for (AbstractMap.SimpleEntry<String, String[]> as : ss) {
+            if (clazz.getAnnotation(Rest.RestDyn.class) != null) continue; //动态生成的跳过
-                sb.append(threadName).append(" Load ").append(as.getKey());
+            WebServlet ws = clazz.getAnnotation(WebServlet.class);
-                for (int i = 0; i < max - as.getKey().length(); i++) {
+            if (ws == null) continue;
-                    sb.append(' ');
+            if (ws.value().length == 0) {
-                }
+                logger.log(Level.INFO, "not found @WebServlet.value in " + clazz.getName());
-                sb.append("  mapping to  ").append(Arrays.toString(as.getValue())).append(LINE_SEPARATOR);
+                continue;
-            }
+            }
-        }
+            RedkaleClassLoader.putReflectionDeclaredConstructors(clazz, clazz.getName());
-        if (rest && serverConf != null) {
+            final HttpServlet servlet = clazz.getDeclaredConstructor().newInstance();
-            final List<Object> restedObjects = new ArrayList<>();
+            resourceFactory.inject(servlet, this);
-            for (AnyValue restConf : serverConf.getAnyValues("rest")) {
+            final String[] mappings = ws.value();
-                loadRestServlet(webSocketFilter, restConf, restedObjects, sb);
+            String pref = ws.repair() ? prefix : "";
-            }
+            DefaultAnyValue servletConf = (DefaultAnyValue) en.getProperty();
-        }
+            this.httpServer.addHttpServlet(servlet, pref, servletConf, mappings);
-        if (sb != null && sb.length() > 0) logger.log(Level.INFO, sb.toString().trim());
+            if (ss != null) {
-    }
+                for (int i = 0; i < mappings.length; i++) {
-
+                    mappings[i] = pref + mappings[i];
-    @SuppressWarnings("unchecked")
+                }
-    protected void loadRestServlet(final ClassFilter<? extends WebSocket> webSocketFilter, final AnyValue restConf, final List<Object> restedObjects, final StringBuilder sb) throws Exception {
+                ss.add(new AbstractMap.SimpleEntry<>("HttpServlet    (type=" + clazz.getName() + ")", mappings));
-        if (!rest) return;
+            }
-        if (restConf == null) return; //不存在REST服务
+        }
-
+        final List<AbstractMap.SimpleEntry<String, String[]>> rests = sb == null ? null : new ArrayList<>();
-        String prefix0 = restConf.getValue("path", "");
+        final List<AbstractMap.SimpleEntry<String, String[]>> webss = sb == null ? null : new ArrayList<>();
-        if (!prefix0.isEmpty() && prefix0.charAt(prefix0.length() - 1) == '/') prefix0 = prefix0.substring(0, prefix0.length() - 1);
+        if (rest && serverConf != null) {
-        if (!prefix0.isEmpty() && prefix0.charAt(0) != '/') prefix0 = '/' + prefix0;
+            final List<Object> restedObjects = new ArrayList<>();
-        final String prefix = prefix0;
+            for (AnyValue restConf : serverConf.getAnyValues("rest")) {
-
+                loadRestServlet(webSocketFilter, restConf, restedObjects, sb, rests, webss);
-        final String threadName = "[" + Thread.currentThread().getName() + "] ";
+            }
-        final List<AbstractMap.SimpleEntry<String, String[]>> ss = sb == null ? null : new ArrayList<>();
+        }
-
+        int max = 0;
-        final boolean autoload = restConf.getBoolValue("autoload", true);
+        if (ss != null && sb != null) {
-        {  //加载RestService
+            int maxTypeLength = 0;
-            String userTypeStr = restConf.getValue("usertype");
+            int maxNameLength = 0;
-            final Class userType = userTypeStr == null ? null : this.serverClassLoader.loadClass(userTypeStr);
+            if (rests != null) {
-
+                for (AbstractMap.SimpleEntry<String, String[]> en : rests) {
-            final Class baseServletType = this.serverClassLoader.loadClass(restConf.getValue("base", HttpServlet.class.getName()));
+                    int pos = en.getKey().indexOf('#');
-            final Set<String> includeValues = new HashSet<>();
+                    if (pos > maxTypeLength) maxTypeLength = pos;
-            final Set<String> excludeValues = new HashSet<>();
+                    int len = en.getKey().length() - pos - 1;
-            for (AnyValue item : restConf.getAnyValues("service")) {
+                    if (len > maxNameLength) maxNameLength = len;
-                if (item.getBoolValue("ignore", false)) {
+                }
-                    excludeValues.add(item.getValue("value", ""));
+            }
-                } else {
+            if (webss != null) {
-                    includeValues.add(item.getValue("value", ""));
+                for (AbstractMap.SimpleEntry<String, String[]> en : webss) {
-                }
+                    int pos = en.getKey().indexOf('#');
-            }
+                    if (pos > maxTypeLength) maxTypeLength = pos;
-
+                    int len = en.getKey().length() - pos - 1;
-            final ClassFilter restFilter = ClassFilter.create(null, restConf.getValue("includes", ""), restConf.getValue("excludes", ""), includeValues, excludeValues);
+                    if (len > maxNameLength) maxNameLength = len;
-            final boolean finest = logger.isLoggable(Level.FINEST);
+                }
-            super.interceptorServices.forEach((service) -> {
+            }
-                final Class stype = Sncp.getServiceType(service);
+            if (rests != null) {
-                final String name = Sncp.getResourceName(service);
+                for (AbstractMap.SimpleEntry<String, String[]> en : rests) {
-                RestService rs = (RestService) stype.getAnnotation(RestService.class);
+                    StringBuilder sub = new StringBuilder();
-                if (rs == null || rs.ignore()) return;
+                    int pos = en.getKey().indexOf('#');
-
+                    sub.append("RestDynServlet (type=").append(en.getKey().substring(0, pos));
-                final String stypename = stype.getName();
+                    for (int i = 0; i < maxTypeLength - pos; i++) {
-                if (!autoload && !includeValues.contains(stypename)) return;
+                        sub.append(' ');
-                if (!restFilter.accept(stypename)) return;
+                    }
-                if (restedObjects.contains(service)) {
+                    sub.append(", name='").append(en.getKey().substring(pos + 1));
-                    logger.log(Level.WARNING, stype.getName() + " repeat create rest servlet, so ignore");
+                    for (int i = 0; i < maxNameLength - pos; i++) {
-                    return;
+                        sub.append(' ');
-                }
+                    }
-                restedObjects.add(service); //避免重复创建Rest对象
+                    sub.append("')");
-                HttpServlet servlet = httpServer.addRestServlet(serverClassLoader, service, userType, baseServletType, prefix);
+                    ss.add(new AbstractMap.SimpleEntry<>(sub.toString(), en.getValue()));
-                if (servlet == null) return; //没有HttpMapping方法的HttpServlet调用Rest.createRestServlet就会返回null 
+                }
-                String prefix2 = prefix;
+            }
-                WebServlet ws = servlet.getClass().getAnnotation(WebServlet.class);
+            if (webss != null) {
-                if (ws != null && !ws.repair()) prefix2 = "";
+                for (AbstractMap.SimpleEntry<String, String[]> en : webss) {
-                resourceFactory.inject(servlet, NodeHttpServer.this);
+                    StringBuilder sub = new StringBuilder();
-                if (finest) logger.finest(threadName + " Create RestServlet(resource.name='" + name + "') = " + servlet);
+                    int pos = en.getKey().indexOf('#');
-                if (ss != null) {
+                    sub.append("RestWebSocket  (type=").append(en.getKey().substring(0, pos));
-                    String[] mappings = servlet.getClass().getAnnotation(WebServlet.class).value();
+                    for (int i = 0; i < maxTypeLength - pos; i++) {
-                    for (int i = 0; i < mappings.length; i++) {
+                        sub.append(' ');
-                        mappings[i] = prefix2 + mappings[i];
+                    }
-                    }
+                    sub.append(", name='").append(en.getKey().substring(pos + 1));
-                    ss.add(new AbstractMap.SimpleEntry<>(servlet.getClass().getName(), mappings));
+                    for (int i = 0; i < maxNameLength - pos; i++) {
-                }
+                        sub.append(' ');
-            });
+                    }
-        }
+                    sub.append("')");
-        if (webSocketFilter != null) {  //加载RestWebSocket
+                    ss.add(new AbstractMap.SimpleEntry<>(sub.toString(), en.getValue()));
-            final Set<String> includeValues = new HashSet<>();
+                }
-            final Set<String> excludeValues = new HashSet<>();
+            }
-            for (AnyValue item : restConf.getAnyValues("websocket")) {
+            ss.sort((AbstractMap.SimpleEntry<String, String[]> o1, AbstractMap.SimpleEntry<String, String[]> o2) -> o1.getKey().compareTo(o2.getKey()));
-                if (item.getBoolValue("ignore", false)) {
+            for (AbstractMap.SimpleEntry<String, String[]> as : ss) {
-                    excludeValues.add(item.getValue("value", ""));
+                if (as.getKey().length() > max) max = as.getKey().length();
-                } else {
+            }
-                    includeValues.add(item.getValue("value", ""));
+            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(' ');
-            final ClassFilter restFilter = ClassFilter.create(null, restConf.getValue("includes", ""), restConf.getValue("excludes", ""), includeValues, excludeValues);
+                }
-            final boolean finest = logger.isLoggable(Level.FINEST);
+                sb.append("  mapping to  ").append(Arrays.toString(as.getValue())).append(LINE_SEPARATOR);
-
+            }
-            List<FilterEntry<? extends WebSocket>> list = new ArrayList(webSocketFilter.getFilterEntrys());
+            sb.append(localThreadName).append("All HttpServlets load cost ").append(System.currentTimeMillis() - starts).append(" ms").append(LINE_SEPARATOR);
-            for (FilterEntry<? extends WebSocket> en : list) {
+        }
-                Class<WebSocket> clazz = (Class<WebSocket>) en.getType();
+        if (sb != null && sb.length() > 0) logger.log(Level.INFO, sb.toString().trim());
-                if (Modifier.isAbstract(clazz.getModifiers())) {
+    }
-                    logger.log(Level.FINE, clazz.getName() + " cannot abstract on rest websocket, so ignore");
+
-                    continue;
+    @SuppressWarnings("unchecked")
-                }
+    protected void loadRestServlet(final ClassFilter<? extends WebSocket> webSocketFilter, final AnyValue restConf, final List<Object> restedObjects, final StringBuilder sb,
-                if (Modifier.isFinal(clazz.getModifiers())) {
+        final List<AbstractMap.SimpleEntry<String, String[]>> rests, final List<AbstractMap.SimpleEntry<String, String[]>> webss) throws Exception {
-                    logger.log(Level.FINE, clazz.getName() + " cannot final on rest websocket, so ignore");
+        if (!rest) return;
-                    continue;
+        if (restConf == null) return; //不存在REST服务
-                }
+
-                final Class<? extends WebSocket> stype = en.getType();
+        String prefix0 = restConf.getValue("path", "");
-                RestWebSocket rs = stype.getAnnotation(RestWebSocket.class);
+        if (!prefix0.isEmpty() && prefix0.charAt(prefix0.length() - 1) == '/') prefix0 = prefix0.substring(0, prefix0.length() - 1);
-                if (rs == null || rs.ignore()) return;
+        if (!prefix0.isEmpty() && prefix0.charAt(0) != '/') prefix0 = '/' + prefix0;
-
+
-                final String stypename = stype.getName();
+        final String localThreadName = "[" + Thread.currentThread().getName() + "] ";
-                if (!autoload && !includeValues.contains(stypename)) return;
+        String mqname = restConf.getValue("mq");
-                if (!restFilter.accept(stypename)) return;
+        MessageAgent agent0 = null;
-                if (restedObjects.contains(stype)) {
+        if (mqname != null) {
-                    logger.log(Level.WARNING, stype.getName() + " repeat create rest websocket, so ignore");
+            agent0 = application.getMessageAgent(mqname);
-                    return;
+            if (agent0 == null) throw new RuntimeException("not found " + MessageAgent.class.getSimpleName() + " config for (name=" + mqname + ")");
-                }
+        }
-                restedObjects.add(stype); //避免重复创建Rest对象
+        final MessageAgent messageAgent = agent0;
-                HttpServlet servlet = httpServer.addRestWebSocketServlet(serverClassLoader, stype, prefix, en.getProperty());
+        if (messageAgent != null) prefix0 = ""; //开启MQ时,prefix字段失效
-                if (servlet == null) return; //没有RestOnMessage方法的HttpServlet调用Rest.createRestWebSocketServlet就会返回null 
+        final String prefix = prefix0;
-                String prefix2 = prefix;
+        final boolean autoload = restConf.getBoolValue("autoload", true);
-                WebServlet ws = servlet.getClass().getAnnotation(WebServlet.class);
+        {  //加载RestService
-                if (ws != null && !ws.repair()) prefix2 = "";
+            String userTypeStr = restConf.getValue("usertype");
-                resourceFactory.inject(servlet, NodeHttpServer.this);
+            final Class userType = userTypeStr == null ? null : this.serverClassLoader.loadClass(userTypeStr);
-                if (finest) logger.finest(threadName + " " + stype.getName() + " create RestWebSocketServlet " + servlet);
+
-                if (ss != null) {
+            final Class baseServletType = this.serverClassLoader.loadClass(restConf.getValue("base", HttpServlet.class.getName()));
-                    String[] mappings = servlet.getClass().getAnnotation(WebServlet.class).value();
+            final Set<String> includeValues = new HashSet<>();
-                    for (int i = 0; i < mappings.length; i++) {
+            final Set<String> excludeValues = new HashSet<>();
-                        mappings[i] = prefix2 + mappings[i];
+            for (AnyValue item : restConf.getAnyValues("service")) {
-                    }
+                if (item.getBoolValue("ignore", false)) {
-                    ss.add(new AbstractMap.SimpleEntry<>(servlet.getClass().getName(), mappings));
+                    excludeValues.add(item.getValue("value", ""));
-                }
+                } else {
-            }
+                    includeValues.add(item.getValue("value", ""));
-        }
+                }
-        //输出信息
+            }
-        if (ss != null && !ss.isEmpty() && sb != null) {
+
-            Collections.sort(ss, (AbstractMap.SimpleEntry<String, String[]> o1, AbstractMap.SimpleEntry<String, String[]> o2) -> o1.getKey().compareTo(o2.getKey()));
+            final ClassFilter restFilter = ClassFilter.create(serverClassLoader, null, application.isCompileMode() ? "" : restConf.getValue("includes", ""), application.isCompileMode() ? "" : restConf.getValue("excludes", ""), includeValues, excludeValues);
-            int max = 0;
+            final CountDownLatch scdl = new CountDownLatch(super.interceptorServices.size());
-            for (AbstractMap.SimpleEntry<String, String[]> as : ss) {
+            Stream<Service> stream = super.interceptorServices.stream();
-                if (as.getKey().length() > max) max = as.getKey().length();
+            if (!application.isCompileMode()) stream = stream.parallel(); //不能并行，否则在maven plugin运行环境下ClassLoader不对
-            }
+            stream.forEach((service) -> {
-            for (AbstractMap.SimpleEntry<String, String[]> as : ss) {
+                try {
-                sb.append(threadName).append(" Load ").append(as.getKey());
+                    final Class stype = Sncp.getServiceType(service);
-                for (int i = 0; i < max - as.getKey().length(); i++) {
+                    final String name = Sncp.getResourceName(service);
-                    sb.append(' ');
+                    RestService rs = (RestService) stype.getAnnotation(RestService.class);
-                }
+                    if (rs == null || rs.ignore()) return;
-                sb.append("  mapping to  ").append(Arrays.toString(as.getValue())).append(LINE_SEPARATOR);
+
-            }
+                    final String stypename = stype.getName();
-        }
+                    if (!autoload && !includeValues.contains(stypename)) return;
-    }
+                    if (!restFilter.accept(stypename)) return;
-}
+                    synchronized (restedObjects) {
+                        if (restedObjects.contains(service)) {
+                            logger.log(Level.WARNING, stype.getName() + " repeat create rest servlet, so ignore");
+                            return;
+                        }
+                        restedObjects.add(service); //避免重复创建Rest对象
+                    }
+                    HttpServlet servlet = httpServer.addRestServlet(serverClassLoader, service, userType, baseServletType, prefix);
+                    if (servlet == null) return; //没有HttpMapping方法的HttpServlet调用Rest.createRestServlet就会返回null 
+                    String prefix2 = prefix;
+                    WebServlet ws = servlet.getClass().getAnnotation(WebServlet.class);
+                    if (ws != null && !ws.repair()) prefix2 = "";
+                    resourceFactory.inject(servlet, NodeHttpServer.this);
+                    dynServletMap.put(service, servlet);
+                    if (messageAgent != null) messageAgent.putService(this, service, servlet);
+                    //if (finest) logger.finest(localThreadName + " Create RestServlet(resource.name='" + name + "') = " + servlet);
+                    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 (rests) {
+                            rests.add(new AbstractMap.SimpleEntry<>(Sncp.getServiceType(service).getName() + "#" + name, mappings));
+                        }
+                    }
+                } finally {
+                    scdl.countDown();
+                }
+            });
+            scdl.await();
+        }
+        if (webSocketFilter != null) {  //加载RestWebSocket
+            final Set<String> includeValues = new HashSet<>();
+            final Set<String> excludeValues = new HashSet<>();
+            for (AnyValue item : restConf.getAnyValues("websocket")) {
+                if (item.getBoolValue("ignore", false)) {
+                    excludeValues.add(item.getValue("value", ""));
+                } else {
+                    includeValues.add(item.getValue("value", ""));
+                }
+            }
+            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());
+            for (FilterEntry<? extends WebSocket> en : list) {
+                Class<WebSocket> clazz = (Class<WebSocket>) en.getType();
+                if (Modifier.isAbstract(clazz.getModifiers())) {
+                    logger.log(Level.FINE, clazz.getName() + " cannot abstract on rest websocket, so ignore");
+                    continue;
+                }
+                if (Modifier.isFinal(clazz.getModifiers())) {
+                    logger.log(Level.FINE, clazz.getName() + " cannot final on rest websocket, so ignore");
+                    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()) continue;
+
+                final String stypename = stype.getName();
+                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");
+                    continue;
+                }
+                restedObjects.add(stype); //避免重复创建Rest对象
+                WebSocketServlet servlet = httpServer.addRestWebSocketServlet(serverClassLoader, stype, messageAgent, prefix, en.getProperty());
+                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 (webss != null) {
+                    String[] mappings = servlet.getClass().getAnnotation(WebServlet.class).value();
+                    for (int i = 0; i < mappings.length; i++) {
+                        mappings[i] = prefix2 + mappings[i];
+                    }
+                    synchronized (webss) {
+                        webss.add(new AbstractMap.SimpleEntry<>(stype.getName() + "#" + rs.name(), mappings));
+                    }
+                }
+            }
+        }
+        if (messageAgent != null) this.messageAgents.put(messageAgent.getName(), messageAgent);
+    }
+
+    @Override //loadServlet执行之后调用
+    protected void postLoadServlets() {
+        final ClusterAgent cluster = application.clusterAgent;
+        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, dynServletMap.keySet(), new HashSet<>());
+        }
+    }
+
+    @Override
+    protected void afterClusterDeregisterOnPreDestroyServices(ClusterAgent cluster, String protocol) {
+        cluster.deregister(this, protocol, dynServletMap.keySet(), new HashSet<>());
+    }
+}

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

@@ -20,5 +20,5 @@ import java.lang.annotation.*;
 @Documented
 public @interface NodeProtocol {
 
-    String[] value();
+    String value();
 }

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

@@ -10,9 +10,10 @@ import java.net.*;
 import java.util.*;
 import java.util.logging.Level;
 import org.redkale.boot.ClassFilter.FilterEntry;
+import org.redkale.mq.MessageAgent;
 import org.redkale.net.*;
 import org.redkale.net.sncp.*;
-import org.redkale.service.Service;
+import org.redkale.service.*;
 import org.redkale.util.*;
 import org.redkale.util.AnyValue.DefaultAnyValue;
 
@@ -24,7 +25,7 @@ import org.redkale.util.AnyValue.DefaultAnyValue;
  *
  * @author zhangjx
  */
-@NodeProtocol({"SNCP"})
+@NodeProtocol("SNCP")
 public class NodeSncpServer extends NodeServer {
 
     protected final SncpServer sncpServer;
@@ -32,19 +33,20 @@ 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 ? null : x -> sncpServer.addSncpServlet(x);
+        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);
+        };
     }
 
     public static NodeServer createNodeServer(Application application, AnyValue serconf) {
-        if (serconf != null && serconf.getAnyValue("rest") != null) {
-            ((AnyValue.DefaultAnyValue) serconf).addValue("_$sncp", "true");
-            return new NodeHttpServer(application, serconf);
-        }
         return new NodeSncpServer(application, serconf);
     }
 
     private static Server createServer(Application application, AnyValue serconf) {
-        return new SncpServer(application.getStartTime());
+        return new SncpServer(application, application.getStartTime(), serconf, application.getResourceFactory().createChild());
     }
 
     @Override
@@ -52,8 +54,8 @@ public class NodeSncpServer extends NodeServer {
         return sncpServer == null ? null : sncpServer.getSocketAddress();
     }
 
-    public void consumerAccept(Service service) {
+    public void consumerAccept(MessageAgent messageAgent, Service service) {
-        if (this.consumer != null) this.consumer.accept(service);
+        if (this.consumer != null) this.consumer.accept(messageAgent, service);
     }
 
     @Override
@@ -62,11 +64,11 @@ public class NodeSncpServer extends NodeServer {
         //-------------------------------------------------------------------
         if (sncpServer == null) return; //调试时server才可能为null
         final StringBuilder sb = logger.isLoggable(Level.FINE) ? new StringBuilder() : null;
-        final String threadName = "[" + Thread.currentThread().getName() + "] ";
+        final String localThreadName = "[" + Thread.currentThread().getName() + "] ";
         List<SncpServlet> servlets = sncpServer.getSncpServlets();
         Collections.sort(servlets);
         for (SncpServlet en : servlets) {
-            if (sb != null) sb.append(threadName).append(" Load ").append(en).append(LINE_SEPARATOR);
+            if (sb != null) sb.append(localThreadName).append(" Load ").append(en).append(LINE_SEPARATOR);
         }
         if (sb != null && sb.length() > 0) logger.log(Level.FINE, sb.toString());
     }
@@ -88,22 +90,25 @@ public class NodeSncpServer extends NodeServer {
     @SuppressWarnings("unchecked")
     protected void loadSncpFilter(final AnyValue servletsConf, final ClassFilter<? extends Filter> classFilter) throws Exception {
         final StringBuilder sb = logger.isLoggable(Level.INFO) ? new StringBuilder() : null;
-        final String threadName = "[" + Thread.currentThread().getName() + "] ";
+        final String localThreadName = "[" + Thread.currentThread().getName() + "] ";
         List<FilterEntry<? extends Filter>> list = new ArrayList(classFilter.getFilterEntrys());
         for (FilterEntry<? extends Filter> en : list) {
             Class<SncpFilter> clazz = (Class<SncpFilter>) en.getType();
             if (Modifier.isAbstract(clazz.getModifiers())) continue;
-            final SncpFilter filter = clazz.newInstance();
+            RedkaleClassLoader.putReflectionDeclaredConstructors(clazz, clazz.getName());
+            final SncpFilter filter = clazz.getDeclaredConstructor().newInstance();
             resourceFactory.inject(filter, this);
             DefaultAnyValue filterConf = (DefaultAnyValue) en.getProperty();
             this.sncpServer.addSncpFilter(filter, filterConf);
-            if (sb != null) sb.append(threadName).append(" Load ").append(clazz.getName()).append(LINE_SEPARATOR);
+            if (sb != null) sb.append(localThreadName).append(" Load ").append(clazz.getName()).append(LINE_SEPARATOR);
         }
         if (sb != null && sb.length() > 0) logger.log(Level.INFO, sb.toString());
     }
 
     @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/NodeWatchServer.java

@@ -16,7 +16,7 @@ import org.redkale.watch.*;
  *
  * @author zhangjx
  */
-@NodeProtocol({"WATCH"})
+@NodeProtocol("WATCH")
 public class NodeWatchServer extends NodeHttpServer {
 
     public NodeWatchServer(Application application, AnyValue serconf) {
@@ -24,16 +24,19 @@ public class NodeWatchServer extends NodeHttpServer {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     protected ClassFilter<Service> createServiceClassFilter() {
         return createClassFilter(this.sncpGroup, null, WatchService.class, null, Annotation.class, "services", "service");
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     protected ClassFilter<Filter> createFilterClassFilter() {
         return createClassFilter(null, null, WatchFilter.class, null, null, "filters", "filter");
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     protected ClassFilter<Servlet> createServletClassFilter() {
         return createClassFilter(null, WebServlet.class, WatchServlet.class, null, null, "servlets", "servlet");
     }

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

@@ -6,6 +6,7 @@
 package org.redkale.boot.watch;
 
 import org.redkale.service.AbstractService;
+import org.redkale.util.Comment;
 import org.redkale.watch.WatchService;
 
 /**
@@ -14,4 +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/boot/watch/FilterWatchService.java

@@ -33,9 +33,9 @@ public class FilterWatchService extends AbstractWatchService {
     public static final int RET_FILTER_JAR_ILLEGAL = 1601_0005;
 
     @Resource
-    private Application application;
+    protected Application application;
 
-    @RestMapping(name = "addfilter", auth = false, comment = "动态增加Filter")
+    @RestMapping(name = "addFilter", auth = false, comment = "动态增加Filter")
     public RetResult addFilter(@RestUploadFile(maxLength = 10 * 1024 * 1024, fileNameReg = "\\.jar$") byte[] jar,
         @RestParam(name = "server", comment = "Server节点名") final String serverName,
         @RestParam(name = "type", comment = "Filter类名") final String filterType) throws IOException {
@@ -47,4 +47,34 @@ public class FilterWatchService extends AbstractWatchService {
         }
         return RetResult.success();
     }
+
+    @RestMapping(name = "test1", auth = false, comment = "预留")
+    public RetResult test1() {
+        return RetResult.success();
+    }
+
+    @RestMapping(name = "test2", auth = false, comment = "预留")
+    public RetResult test2() {
+        return RetResult.success();
+    }
+
+    @RestMapping(name = "test3", auth = false, comment = "预留")
+    public RetResult test3() {
+        return RetResult.success();
+    }
+
+    @RestMapping(name = "test4", auth = false, comment = "预留")
+    public RetResult test4() {
+        return RetResult.success();
+    }
+
+    @RestMapping(name = "test5", auth = false, comment = "预留")
+    public RetResult test5() {
+        return RetResult.success();
+    }
+
+    @RestMapping(name = "test6", auth = false, comment = "预留")
+    public RetResult test6() {
+        return RetResult.success();
+    }
 }

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

@@ -0,0 +1,104 @@
+/*
+ * 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.watch;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.util.*;
+import java.util.stream.Stream;
+import javax.annotation.Resource;
+import org.redkale.boot.*;
+import org.redkale.net.Server;
+import org.redkale.net.http.*;
+import org.redkale.service.RetResult;
+import org.redkale.util.Comment;
+
+/**
+ *
+ * @author zhangjx
+ */
+@RestService(name = "server", catalog = "watch", repair = false)
+public class ServerWatchService extends AbstractWatchService {
+
+    @Comment("不存在的Server节点")
+    public static final int RET_SERVER_NOT_EXISTS = 1602_0001;
+
+    @Comment("更改Server监听地址端口失败")
+    public static final int RET_SERVER_CHANGEPORT_ERROR = 1602_0002;
+
+    @Resource
+    protected Application application;
+
+    @RestMapping(name = "info", comment = "单个Server信息查询")
+    public RetResult info(@RestParam(name = "#port:") final int port) {
+        Stream<NodeServer> stream = application.getNodeServers().stream();
+        NodeServer node = stream.filter(ns -> ns.getServer().getSocketAddress().getPort() == port).findFirst().orElse(null);
+        if (node == null) return new RetResult(RET_SERVER_NOT_EXISTS, "Server(port=" + port + ") not found");
+        return new RetResult(formatToMap(node));
+    }
+
+    @RestMapping(name = "infos", comment = "Server信息查询")
+    public RetResult infos() {
+        Map<String, Object> rs = new LinkedHashMap<>();
+        for (NodeServer ns : application.getNodeServers()) {
+            Server server = ns.getServer();
+            rs.put("" + server.getSocketAddress().getPort(), formatToMap(ns));
+        }
+        return new RetResult(rs);
+    }
+
+    @RestMapping(name = "changeAddress", comment = "更改Server的监听地址和端口")
+    public RetResult changeAddress(@RestParam(name = "#port:") final int oldport,
+        @RestParam(name = "#newhost:") final String newhost, @RestParam(name = "#newport:") final int newport) {
+        if (oldport < 1) return new RetResult(RET_WATCH_PARAMS_ILLEGAL, "not found param `oldport`");
+        if (newport < 1) return new RetResult(RET_WATCH_PARAMS_ILLEGAL, "not found param `newport`");
+        Stream<NodeServer> stream = application.getNodeServers().stream();
+        NodeServer node = stream.filter(ns -> ns.getServer().getSocketAddress().getPort() == oldport).findFirst().orElse(null);
+        if (node == null) return new RetResult(RET_SERVER_NOT_EXISTS, "Server(port=" + oldport + ") not found");
+        final Server server = node.getServer();
+        InetSocketAddress newAddr = new InetSocketAddress(newhost == null || newhost.isEmpty() ? server.getSocketAddress().getHostString() : newhost, newport);
+        try {
+            server.changeAddress(application, newAddr);
+        } catch (IOException e) {
+            e.printStackTrace();
+            return new RetResult(RET_SERVER_CHANGEPORT_ERROR, "changeaddress error");
+        }
+        return RetResult.success();
+    }
+
+    private Map<String, Object> formatToMap(NodeServer node) {
+        Server server = node.getServer();
+        Map<String, Object> rs = new LinkedHashMap<>();
+        String protocol = server.getNetprotocol();
+        if (node instanceof NodeSncpServer) {
+            protocol += "/SNCP";
+        } else if (node instanceof NodeWatchServer) {
+            protocol += "/WATCH";
+        } else if (node instanceof NodeHttpServer) {
+            protocol += "/HTTP";
+        } else {
+            NodeProtocol np = node.getClass().getAnnotation(NodeProtocol.class);
+            protocol += "/" + np.value();
+        }
+        rs.put("name", server.getName());
+        rs.put("protocol", protocol);
+        rs.put("address", server.getSocketAddress());
+        rs.put("backlog", server.getBacklog());
+        rs.put("bufferCapacity", server.getBufferCapacity());
+        rs.put("bufferPoolSize", server.getBufferPoolSize());
+        rs.put("charset", server.getCharset() == null ? "UTF-8" : server.getCharset().name());
+        rs.put("maxbody", server.getMaxbody());
+        rs.put("maxconns", server.getMaxconns());
+        rs.put("serverStartTime", server.getServerStartTime());
+        rs.put("responsePoolSize", server.getResponsePoolSize());
+        rs.put("readTimeoutSeconds", server.getReadTimeoutSeconds());
+        rs.put("writeTimeoutSeconds", server.getWriteTimeoutSeconds());
+        rs.put("createConnectionCount", server.getCreateConnectionCount());
+        rs.put("livingConnectionCount", server.getLivingConnectionCount());
+        rs.put("closedConnectionCount", server.getClosedConnectionCount());
+        return rs;
+    }
+}

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

@@ -0,0 +1,199 @@
+/*
+ * 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.watch;
+
+import java.lang.reflect.*;
+import java.util.*;
+import javax.annotation.Resource;
+import org.redkale.boot.*;
+import org.redkale.convert.json.JsonConvert;
+import org.redkale.net.http.*;
+import org.redkale.service.RetResult;
+import org.redkale.util.*;
+
+/**
+ * <p>
+ * 详情见: https://redkale.org
+ *
+ * @author zhangjx
+ */
+@RestService(name = "service", catalog = "watch", repair = false)
+public class ServiceWatchService extends AbstractWatchService {
+
+    @Comment("没有找到目标Service")
+    public static final int RET_SERVICE_DEST_NOT_EXISTS = 1603_0001;
+
+    @Resource
+    protected Application application;
+
+    @RestConvert(type = void.class)
+    @RestMapping(name = "setField", auth = false, comment = "设置Service中指定字段的内容")
+    public RetResult setField(@RestParam(name = "name", comment = "Service的资源名") String name,
+        @RestParam(name = "type", comment = "Service的类名") String type,
+        @RestParam(name = "field", comment = "字段名") String field,
+        @RestParam(name = "value", comment = "字段值") String value) {
+        if (name == null) name = "";
+        if (type == null) type = "";
+        if (field == null) field = "";
+        type = type.trim();
+        field = field.trim();
+        if (type.isEmpty()) return new RetResult(RET_WATCH_PARAMS_ILLEGAL, "not found param `type`");
+        if (field.isEmpty()) return new RetResult(RET_WATCH_PARAMS_ILLEGAL, "not found param `field`");
+        Object dest = findService(name, type);
+        Class clazz = dest.getClass();
+        Throwable t = null;
+        try {
+            Field fieldObj = null;
+            do {
+                try {
+                    fieldObj = clazz.getDeclaredField(field);
+                    break;
+                } catch (Exception e) {
+                    if (t == null) t = e;
+                }
+            } while ((clazz = clazz.getSuperclass()) != Object.class);
+            if (fieldObj == null) return new RetResult(RET_WATCH_RUN_EXCEPTION, "run exception (" + String.valueOf(t) + ")");
+            fieldObj.setAccessible(true);
+            fieldObj.set(dest, JsonConvert.root().convertFrom(fieldObj.getGenericType(), value));
+            return RetResult.success();
+        } catch (Throwable t2) {
+            return new RetResult(RET_WATCH_RUN_EXCEPTION, "run exception (" + t2.toString() + ")");
+        }
+    }
+
+    @RestConvert(type = void.class)
+    @RestMapping(name = "getField", auth = false, comment = "查询Service中指定字段的内容")
+    public RetResult getField(@RestParam(name = "name", comment = "Service的资源名") String name,
+        @RestParam(name = "type", comment = "Service的类名") String type,
+        @RestParam(name = "field", comment = "字段名") String field) {
+        if (name == null) name = "";
+        if (type == null) type = "";
+        if (field == null) field = "";
+        type = type.trim();
+        field = field.trim();
+        if (type.isEmpty()) return new RetResult(RET_WATCH_PARAMS_ILLEGAL, "not found param `type`");
+        if (field.isEmpty()) return new RetResult(RET_WATCH_PARAMS_ILLEGAL, "not found param `field`");
+        Object dest = findService(name, type);
+        Class clazz = dest.getClass();
+        Throwable t = null;
+        try {
+            Field fieldObj = null;
+            do {
+                try {
+                    fieldObj = clazz.getDeclaredField(field);
+                    break;
+                } catch (Exception e) {
+                    if (t == null) t = e;
+                }
+            } while ((clazz = clazz.getSuperclass()) != Object.class);
+            if (fieldObj == null) return new RetResult(RET_WATCH_RUN_EXCEPTION, "run exception (" + String.valueOf(t) + ")");
+            fieldObj.setAccessible(true);
+            return new RetResult(fieldObj.get(dest));
+        } catch (Throwable t2) {
+            return new RetResult(RET_WATCH_RUN_EXCEPTION, "run exception (" + t2.toString() + ")");
+        }
+    }
+
+    @RestConvert(type = void.class)
+    @RestMapping(name = "runMethod", auth = false, comment = "调用Service中指定方法")
+    public RetResult runMethod(@RestParam(name = "name", comment = "Service的资源名") String name,
+        @RestParam(name = "type", comment = "Service的类名") String type,
+        @RestParam(name = "method", comment = "Service的方法名") String method,
+        @RestParam(name = "params", comment = "方法的参数值") List<String> params,
+        @RestParam(name = "paramtypes", comment = "方法的参数数据类型") List<String> paramtypes) {
+        if (name == null) name = "";
+        if (type == null) type = "";
+        if (method == null) method = "";
+        type = type.trim();
+        method = method.trim();
+        if (type.isEmpty()) return new RetResult(RET_WATCH_PARAMS_ILLEGAL, "not found param `type`");
+        if (method.isEmpty()) return new RetResult(RET_WATCH_PARAMS_ILLEGAL, "not found param `method`");
+        Object dest = findService(name, type);
+        Class clazz = dest.getClass();
+        Throwable t = null;
+        final int paramcount = params == null ? 0 : params.size();
+        if (paramtypes != null && paramcount != paramtypes.size()) return new RetResult(RET_WATCH_PARAMS_ILLEGAL, "params.size not equals to paramtypes.size");
+        try {
+            Method methodObj = null;
+            do {
+                try {
+                    for (Method m : clazz.getDeclaredMethods()) {
+                        if (m.getName().equals(method) && m.getParameterCount() == paramcount) {
+                            boolean flag = true;
+                            if (paramtypes != null) {
+                                Class[] pts = m.getParameterTypes();
+                                for (int i = 0; i < pts.length; i++) {
+                                    if (!pts[i].getName().endsWith(paramtypes.get(i))) {
+                                        flag = false;
+                                        break;
+                                    }
+                                }
+                            }
+                            if (flag) {
+                                methodObj = m;
+                                break;
+                            }
+                        }
+                    }
+                    if (methodObj != null) break;
+                } catch (Exception e) {
+                    if (t == null) t = e;
+                }
+            } while ((clazz = clazz.getSuperclass()) != Object.class);
+            if (methodObj == null) return new RetResult(RET_WATCH_RUN_EXCEPTION, "run exception (" + (t == null ? ("not found method(" + method + ")") : String.valueOf(t)) + ")");
+            methodObj.setAccessible(true);
+            if (paramcount < 1) return new RetResult(methodObj.invoke(dest));
+            Object[] paramObjs = new Object[paramcount];
+            Type[] pts = methodObj.getGenericParameterTypes();
+            for (int i = 0; i < paramObjs.length; i++) {
+                paramObjs[i] = JsonConvert.root().convertFrom(pts[i], params.get(i));
+            }
+            return new RetResult(methodObj.invoke(dest, paramObjs));
+        } catch (Throwable t2) {
+            return new RetResult(RET_WATCH_RUN_EXCEPTION, "run exception (" + t2.toString() + ")");
+        }
+    }
+
+    protected Object findService(String name, String type) {
+        Object dest = null;
+        for (NodeServer ns : application.getNodeServers()) {
+            ResourceFactory resFactory = ns.getResourceFactory();
+            List list = resFactory.query((n, s) -> name.equals(n) && s != null && s.getClass().getName().endsWith(type));
+            if (list == null || list.isEmpty()) continue;
+            dest = list.get(0);
+        }
+        if (dest == null) return new RetResult(RET_SERVICE_DEST_NOT_EXISTS, "not found servie (name=" + name + ", type=" + type + ")");
+        return dest;
+    }
+
+    @RestMapping(name = "loadService", auth = false, comment = "动态增加Service")
+    public RetResult loadService(@RestParam(name = "type", comment = "Service的类名") String type,
+        @RestUploadFile(maxLength = 10 * 1024 * 1024, fileNameReg = "\\.jar$") byte[] jar) {
+        //待开发
+        return RetResult.success();
+    }
+
+    @RestMapping(name = "reloadService", auth = false, comment = "重新加载Service")
+    public RetResult reloadService(@RestParam(name = "name", comment = "Service的资源名") String name,
+        @RestParam(name = "type", comment = "Service的类名") String type) {
+        //待开发
+        return RetResult.success();
+    }
+
+    @RestMapping(name = "stopService", auth = false, comment = "动态停止Service")
+    public RetResult stopService(@RestParam(name = "name", comment = "Service的资源名") String name,
+        @RestParam(name = "type", comment = "Service的类名") String type) {
+        //待开发
+        return RetResult.success();
+    }
+
+    @RestMapping(name = "findService", auth = false, comment = "查找Service")
+    public RetResult find(@RestParam(name = "name", comment = "Service的资源名") String name,
+        @RestParam(name = "type", comment = "Service的类名") String type) {
+        //待开发
+        return RetResult.success();
+    }
+}

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

@@ -20,18 +20,18 @@ import org.redkale.net.http.*;
 public class ServletWatchService extends AbstractWatchService {
 
     @Resource
-    private Application application;
+    protected Application application;
 
     @Resource
-    private TransportFactory transportFactory;
+    protected TransportFactory transportFactory;
 //
-//    @RestMapping(name = "load", auth = false, comment = "动态增加Servlet")
+//    @RestMapping(name = "loadServlet", auth = false, comment = "动态增加Servlet")
 //    public RetResult loadServlet(String type, @RestUploadFile(maxLength = 10 * 1024 * 1024, fileNameReg = "\\.jar$") byte[] jar) {
 //        //待开发
 //        return RetResult.success();
 //    }
 //
-//    @RestMapping(name = "stop", auth = false, comment = "动态停止Servlet")
+//    @RestMapping(name = "stopServlet", auth = false, comment = "动态停止Servlet")
 //    public RetResult stopServlet(String type) {
 //        //待开发
 //        return RetResult.success();

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

@@ -36,10 +36,10 @@ public class TransportWatchService extends AbstractWatchService {
     public static final int RET_TRANSPORT_ADDR_EXISTS = 1606_0003;
 
     @Resource
-    private Application application;
+    protected Application application;
 
     @Resource
-    private TransportFactory transportFactory;
+    protected TransportFactory transportFactory;
 
     @RestMapping(name = "listnodes", auth = false, comment = "获取所有Node节点")
     public List<TransportGroupInfo> listNodes() {
@@ -72,15 +72,6 @@ public class TransportWatchService extends AbstractWatchService {
                     if (client.getRemoteGroups() != null && client.getRemoteGroups().contains(group)) {
                         client.getRemoteGroupTransport().addRemoteAddresses(address);
                     }
-                } else {
-                    if (group.equals(client.getSameGroup())) {
-                        client.getSameGroupTransport().addRemoteAddresses(address);
-                    }
-                    if (client.getDiffGroups() != null && client.getDiffGroups().contains(group)) {
-                        for (Transport transport : client.getDiffGroupTransports()) {
-                            transport.addRemoteAddresses(address);
-                        }
-                    }
                 }
             }
             DefaultAnyValue node = DefaultAnyValue.create("addr", addr).addValue("port", port);
@@ -90,7 +81,7 @@ public class TransportWatchService extends AbstractWatchService {
                     break;
                 }
             }
-            application.restoreConfig();
+            //application.restoreConfig();
         }
         return RetResult.success();
     }
@@ -114,15 +105,6 @@ public class TransportWatchService extends AbstractWatchService {
                     if (client.getRemoteGroups() != null && client.getRemoteGroups().contains(group)) {
                         client.getRemoteGroupTransport().removeRemoteAddresses(address);
                     }
-                } else {
-                    if (group.equals(client.getSameGroup())) {
-                        client.getSameGroupTransport().removeRemoteAddresses(address);
-                    }
-                    if (client.getDiffGroups() != null && client.getDiffGroups().contains(group)) {
-                        for (Transport transport : client.getDiffGroupTransports()) {
-                            transport.removeRemoteAddresses(address);
-                        }
-                    }
                 }
             }
             for (AnyValue groupconf : application.getAppConfig().getAnyValue("resources").getAnyValues("group")) {
@@ -131,8 +113,28 @@ public class TransportWatchService extends AbstractWatchService {
                     break;
                 }
             }
-            application.restoreConfig();
+            //application.restoreConfig();
         }
         return RetResult.success();
     }
+
+    @RestMapping(name = "test1", auth = false, comment = "预留")
+    public RetResult test1() {
+        return RetResult.success();
+    }
+
+    @RestMapping(name = "test2", auth = false, comment = "预留")
+    public RetResult test2() {
+        return RetResult.success();
+    }
+
+    @RestMapping(name = "test3", auth = false, comment = "预留")
+    public RetResult test3() {
+        return RetResult.success();
+    }
+
+    @RestMapping(name = "test4", auth = false, comment = "预留")
+    public RetResult test4() {
+        return RetResult.success();
+    }
 }

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

@@ -0,0 +1,315 @@
+/*
+ * 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 java.net.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.logging.Level;
+import javax.annotation.Resource;
+import org.redkale.boot.*;
+import org.redkale.convert.json.JsonConvert;
+import org.redkale.service.Service;
+import org.redkale.source.CacheSource;
+import org.redkale.util.*;
+
+/**
+ * 使用CacheSource实现的第三方服务发现管理接口cluster
+ *
+ *
+ * 详情见: https://redkale.org
+ *
+ * @author zhangjx
+ *
+ * @since 2.3.0
+ */
+public class CacheClusterAgent extends ClusterAgent implements Resourcable {
+
+    @Resource(name = "$")
+    private CacheSource source;
+
+    private String sourceName;
+
+    protected int ttls = 10; //定时检查的秒数
+
+    protected ScheduledThreadPoolExecutor scheduler;
+
+    //可能被HttpMessageClient用到的服务 key: serviceName
+    protected final ConcurrentHashMap<String, Collection<InetSocketAddress>> httpAddressMap = new ConcurrentHashMap<>();
+
+    //可能被mqtp用到的服务 key: serviceName
+    protected final ConcurrentHashMap<String, Collection<InetSocketAddress>> mqtpAddressMap = new ConcurrentHashMap<>();
+
+    @Override
+    public void init(ResourceFactory factory, AnyValue config) {
+        super.init(factory, config);
+
+        this.sourceName = getSourceName();
+
+        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
+    public void destroy(AnyValue config) {
+        if (scheduler != null) scheduler.shutdownNow();
+    }
+
+    public String getSourceName() {
+        return config.getValue("source");
+    }
+
+    @Override
+    public String resourceName() {
+        return sourceName;
+    }
+
+    @Override //ServiceLoader时判断配置是否符合当前实现类
+    public boolean acceptsConf(AnyValue config) {
+        if (config == null) return false;
+        return config.getValue("source") != null;
+    }
+
+    @Override
+    public void start() {
+        if (this.scheduler == null) {
+            this.scheduler = new ScheduledThreadPoolExecutor(4, (Runnable r) -> {
+                final Thread t = new Thread(r, "Redkale-" + CacheClusterAgent.class.getSimpleName() + "-Task-Thread");
+                t.setDaemon(true);
+                return t;
+            });
+
+            this.scheduler.scheduleAtFixedRate(() -> {
+                try {
+                    checkApplicationHealth();
+                    checkHttpAddressHealth();
+                    loadMqtpAddressHealth();
+                    localEntrys.values().stream().filter(e -> !e.canceled).forEach(entry -> {
+                        checkLocalHealth(entry);
+                    });
+                    remoteEntrys.values().stream().filter(entry -> "SNCP".equalsIgnoreCase(entry.protocol)).forEach(entry -> {
+                        updateSncpTransport(entry);
+                    });
+                } catch (Exception 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);
+        }
+    }
+
+    protected void loadMqtpAddressHealth() {
+        List<String> keys = source.queryKeysStartsWith("cluster.mqtp:");
+        keys.forEach(serviceName -> {
+            try {
+                this.mqtpAddressMap.put(serviceName, queryAddress(serviceName).get(3, TimeUnit.SECONDS));
+            } catch (Exception e) {
+                logger.log(Level.SEVERE, "loadMqtpAddressHealth check " + serviceName + " error", e);
+            }
+        });
+    }
+
+    protected void checkHttpAddressHealth() {
+        try {
+            this.httpAddressMap.keySet().stream().forEach(serviceName -> {
+                try {
+                    this.httpAddressMap.put(serviceName, queryAddress(serviceName).get(3, TimeUnit.SECONDS));
+                } catch (Exception e) {
+                    logger.log(Level.SEVERE, "checkHttpAddressHealth check " + serviceName + " error", e);
+                }
+            });
+        } catch (Exception ex) {
+            logger.log(Level.SEVERE, "checkHttpAddressHealth check error", ex);
+        }
+    }
+
+    protected void checkLocalHealth(final ClusterEntry entry) {
+        AddressEntry newaddr = new AddressEntry();
+        newaddr.addr = entry.address;
+        newaddr.nodeid = this.nodeid;
+        newaddr.time = System.currentTimeMillis();
+        source.hset(entry.checkName, entry.checkid, AddressEntry.class, newaddr);
+    }
+
+    @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) + ":";
+        mqtpAddressMap.keySet().stream().filter(k -> k.startsWith(servicenamprefix))
+            .forEach(sn -> rsmap.put(sn.substring(servicenamprefix.length()), mqtpAddressMap.get(sn)));
+        return CompletableFuture.completedFuture(rsmap);
+    }
+
+    @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);
+        if (rs != null) return CompletableFuture.completedFuture(rs);
+        return queryAddress(serviceName).thenApply(t -> {
+            httpAddressMap.put(serviceName, t);
+            return t;
+        });
+    }
+
+    @Override
+    protected CompletableFuture<Collection<InetSocketAddress>> queryAddress(final ClusterEntry entry) {
+        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);
+        return future.thenApply(map -> {
+            final Set<InetSocketAddress> set = new HashSet<>();
+            map.forEach((n, v) -> {
+                if (v != null && (System.currentTimeMillis() - v.time) / 1000 < ttls) set.add(v.addr);
+            });
+            return set;
+        });
+    }
+
+    protected boolean isApplicationHealth() {
+        String serviceName = generateApplicationServiceName();
+        String serviceid = generateApplicationServiceId();
+        AddressEntry entry = (AddressEntry) source.hget(serviceName, serviceid, AddressEntry.class);
+        return entry != null && (System.currentTimeMillis() - entry.time) / 1000 < ttls;
+    }
+
+    protected void checkApplicationHealth() {
+        String checkname = generateApplicationServiceName();
+        String checkid = generateApplicationCheckId();
+        AddressEntry entry = new AddressEntry();
+        entry.addr = this.appAddress;
+        entry.nodeid = this.nodeid;
+        entry.time = System.currentTimeMillis();
+        source.hset(checkname, checkid, AddressEntry.class, entry);
+    }
+
+    @Override
+    public void register(Application application) {
+        if (isApplicationHealth()) throw new RuntimeException("application.nodeid=" + nodeid + " exists in cluster");
+        deregister(application);
+
+        String serviceid = generateApplicationServiceId();
+        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);
+    }
+
+    @Override
+    public void deregister(Application application) {
+        String serviceName = generateApplicationServiceName();
+        source.remove(serviceName);
+    }
+
+    @Override
+    protected ClusterEntry register(NodeServer ns, String protocol, Service service) {
+        deregister(ns, protocol, service, false);
+        //
+        ClusterEntry clusterEntry = new ClusterEntry(ns, protocol, service);
+        AddressEntry entry = new AddressEntry();
+        entry.addr = clusterEntry.address;
+        entry.nodeid = this.nodeid;
+        entry.time = System.currentTimeMillis();
+        source.hset(clusterEntry.serviceName, clusterEntry.serviceid, AddressEntry.class, entry);
+        return clusterEntry;
+    }
+
+    @Override
+    protected void deregister(NodeServer ns, String protocol, Service service) {
+        deregister(ns, protocol, service, true);
+    }
+
+    protected void deregister(NodeServer ns, String protocol, Service service, boolean realcanceled) {
+        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)) {
+                currEntry = entry;
+                break;
+            }
+        }
+        if (currEntry == null) {
+            for (final ClusterEntry entry : remoteEntrys.values()) {
+                if (entry.serviceName.equals(serviceName) && entry.serviceid.equals(serviceid)) {
+                    currEntry = entry;
+                    break;
+                }
+            }
+        }
+        source.hremove(serviceName, serviceid);
+        if (realcanceled && currEntry != null) currEntry.canceled = true;
+        if (!"mqtp".equals(protocol) && currEntry != null && currEntry.submqtp) {
+            deregister(ns, "mqtp", service, realcanceled);
+        }
+    }
+
+    @Override
+    protected String generateApplicationServiceName() {
+        return "cluster." + super.generateApplicationServiceName();
+    }
+
+    @Override
+    protected String generateServiceName(NodeServer ns, String protocol, Service service) {
+        return "cluster." + super.generateServiceName(ns, protocol, service);
+    }
+
+    @Override
+    public String generateHttpServiceName(String protocol, String module, String resname) {
+        return "cluster." + super.generateHttpServiceName(protocol, module, resname);
+    }
+
+    @Override
+    protected String generateApplicationCheckName() {
+        return generateApplicationServiceName();
+    }
+
+    @Override
+    protected String generateApplicationCheckId() {
+        return generateApplicationServiceId();
+    }
+
+    @Override
+    protected String generateCheckName(NodeServer ns, String protocol, Service service) {
+        return generateServiceName(ns, protocol, service);
+    }
+
+    @Override
+    protected String generateCheckId(NodeServer ns, String protocol, Service service) {
+        return generateServiceId(ns, protocol, service);
+    }
+
+    public static class AddressEntry {
+
+        public InetSocketAddress addr;
+
+        public int nodeid;
+
+        public long time;
+
+        public AddressEntry() {
+        }
+
+        public AddressEntry refresh() {
+            this.time = System.currentTimeMillis();
+            return this;
+        }
+
+        @Override
+        public String toString() {
+            return JsonConvert.root().convertTo(this);
+        }
+    }
+
+}

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

@@ -0,0 +1,369 @@
+/*
+ * 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 java.lang.ref.WeakReference;
+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.*;
+import org.redkale.net.http.*;
+import org.redkale.net.sncp.*;
+import org.redkale.service.*;
+import org.redkale.util.*;
+
+/**
+ * 第三方服务发现管理接口cluster
+ *
+ *
+ * 详情见: https://redkale.org
+ *
+ * @author zhangjx
+ *
+ * @since 2.1.0
+ */
+public abstract class ClusterAgent {
+
+    protected final Logger logger = Logger.getLogger(this.getClass().getSimpleName());
+
+    @Resource(name = RESNAME_APP_NODEID)
+    protected int nodeid;
+
+    @Resource(name = RESNAME_APP_NAME)
+    protected String appName = "";
+
+    @Resource(name = RESNAME_APP_ADDR)
+    protected InetSocketAddress appAddress;
+
+    protected String name;
+
+    protected boolean waits;
+
+    protected String[] protocols; //必须全大写
+
+    protected int[] ports;
+
+    protected AnyValue config;
+
+    protected TransportFactory transportFactory;
+
+    protected final ConcurrentHashMap<String, ClusterEntry> localEntrys = new ConcurrentHashMap<>();
+
+    protected final ConcurrentHashMap<String, ClusterEntry> remoteEntrys = new ConcurrentHashMap<>();
+
+    public void init(ResourceFactory factory, AnyValue config) {
+        this.config = config;
+        this.name = config.getValue("name", "");
+        this.waits = config.getBoolValue("waits", false);
+        {
+            String ps = config.getValue("protocols", "").toUpperCase();
+            if (ps == null || ps.isEmpty()) ps = "SNCP;HTTP";
+            this.protocols = ps.split(";");
+        }
+        String ts = config.getValue("ports", "");
+        if (ts != null && !ts.isEmpty()) {
+            String[] its = ts.split(";");
+            List<Integer> list = new ArrayList<>();
+            for (String str : its) {
+                if (str.trim().isEmpty()) continue;
+                list.add(Integer.parseInt(str.trim()));
+            }
+            if (!list.isEmpty()) this.ports = list.stream().mapToInt(x -> x).toArray();
+        }
+    }
+
+    public void destroy(AnyValue config) {
+    }
+
+    //ServiceLoader时判断配置是否符合当前实现类
+    public abstract boolean acceptsConf(AnyValue config);
+
+    public boolean containsProtocol(String protocol) {
+        if (protocol == null || protocol.isEmpty()) return false;
+        return protocols == null || Utility.contains(protocols, protocol.toUpperCase());
+    }
+
+    public boolean containsPort(int port) {
+        if (ports == null || ports.length == 0) return true;
+        return Utility.contains(ports, port);
+    }
+
+    public abstract void register(Application application);
+
+    public abstract void deregister(Application application);
+
+    //注册服务, 在NodeService调用Service.init方法之前调用
+    public void register(NodeServer ns, String protocol, Set<Service> localServices, Set<Service> remoteServices) {
+        if (localServices.isEmpty()) return;
+        //注册本地模式
+        for (Service service : localServices) {
+            if (!canRegister(ns, protocol, service)) continue;
+            ClusterEntry htentry = register(ns, protocol, service);
+            localEntrys.put(htentry.serviceid, htentry);
+            if (protocol.toLowerCase().startsWith("http")) {
+                MessageMultiConsumer mmc = service.getClass().getAnnotation(MessageMultiConsumer.class);
+                if (mmc != null) {
+                    ClusterEntry mqentry = register(ns, "mqtp", service);
+                    localEntrys.put(mqentry.serviceid, mqentry);
+                    htentry.submqtp = true;
+                }
+            }
+        }
+        //远程模式加载IP列表, 只支持SNCP协议    
+        if (ns.isSNCP()) {
+            for (Service service : remoteServices) {
+                ClusterEntry entry = new ClusterEntry(ns, protocol, service);
+                updateSncpTransport(entry);
+                remoteEntrys.put(entry.serviceid, entry);
+            }
+        }
+    }
+
+    //注销服务, 在NodeService调用Service.destroy 方法之前调用
+    public void deregister(NodeServer ns, String protocol, Set<Service> localServices, Set<Service> remoteServices) {
+        //注销本地模式  远程模式不注册
+        for (Service service : localServices) {
+            if (!canRegister(ns, protocol, service)) continue;
+            deregister(ns, protocol, service);
+        }
+        afterDeregister(ns, protocol);
+    }
+
+    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;
+    }
+
+    public void start() {
+    }
+
+    protected void afterDeregister(NodeServer ns, String protocol) {
+        if (!this.waits) return;
+        int s = intervalCheckSeconds();
+        if (s > 0) {  //暂停，弥补其他依赖本进程服务的周期偏差
+            try {
+                Thread.sleep(s * 1000);
+            } catch (InterruptedException ex) {
+            }
+            logger.info(this.getClass().getSimpleName() + " wait for " + s * 1000 + "ms after deregister");
+        }
+    }
+
+    public int intervalCheckSeconds() {
+        return 10;
+    }
+
+    //获取MQTP的HTTP远程服务的可用ip列表, key = serviceName的后半段
+    public abstract CompletableFuture<Map<String, Collection<InetSocketAddress>>> queryMqtpAddress(String protocol, String module, String resname);
+
+    //获取HTTP远程服务的可用ip列表
+    public abstract CompletableFuture<Collection<InetSocketAddress>> queryHttpAddress(String protocol, String module, String resname);
+
+    //获取远程服务的可用ip列表
+    protected abstract CompletableFuture<Collection<InetSocketAddress>> queryAddress(ClusterEntry entry);
+
+    //注册服务
+    protected abstract ClusterEntry register(NodeServer ns, String protocol, Service service);
+
+    //注销服务
+    protected abstract void deregister(NodeServer ns, String protocol, Service service);
+
+    //格式: protocol:classtype-resourcename
+    protected void updateSncpTransport(ClusterEntry entry) {
+        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);
+    }
+
+    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;
+    }
+
+    protected String generateApplicationServiceType() {
+        return "application.nodes";
+    }
+
+    protected String generateApplicationServiceId() { //与serviceName相同
+        return generateApplicationServiceName();
+    }
+
+    protected String generateApplicationCheckName() {
+        return "check-" + generateApplicationServiceName();
+    }
+
+    protected String generateApplicationCheckId() {
+        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() + serviceSeparator() + module + (resname == null || resname.isEmpty() ? "" : ("-" + resname));
+    }
+
+    //格式: protocol:classtype-resourcename
+    protected String generateServiceName(NodeServer ns, String protocol, Service service) {
+        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() + 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() + serviceSeparator() + mmc.module() + serviceSeparator() + selfmodule;
+        }
+        if (!Sncp.isSncpDyn(service)) return protocol.toLowerCase() + serviceSeparator() + service.getClass().getName();
+        String resname = Sncp.getResourceName(service);
+        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) + serviceSeparator() + this.nodeid;
+    }
+
+    protected String generateCheckName(NodeServer ns, String protocol, Service service) {
+        return "check-" + generateServiceName(ns, protocol, service);
+    }
+
+    protected String generateCheckId(NodeServer ns, String protocol, Service service) {
+        return "check-" + generateServiceId(ns, protocol, service);
+    }
+
+    protected ConcurrentHashMap<String, ClusterEntry> getLocalEntrys() {
+        return localEntrys;
+    }
+
+    protected ConcurrentHashMap<String, ClusterEntry> getRemoteEntrys() {
+        return remoteEntrys;
+    }
+
+    public TransportFactory getTransportFactory() {
+        return transportFactory;
+    }
+
+    public void setTransportFactory(TransportFactory transportFactory) {
+        this.transportFactory = transportFactory;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String[] getProtocols() {
+        return protocols;
+    }
+
+    public void setProtocols(String[] protocols) {
+        this.protocols = protocols;
+    }
+
+    public int[] getPorts() {
+        return ports;
+    }
+
+    public void setPorts(int[] ports) {
+        this.ports = ports;
+    }
+
+    public AnyValue getConfig() {
+        return config;
+    }
+
+    public void setConfig(AnyValue config) {
+        this.config = config;
+    }
+
+    public class ClusterEntry {
+
+        //serviceName+nodeid为主  服务的单个实例
+        public String serviceid;
+
+        //以协议+Rest资源名为主  服务类名
+        public String serviceName;
+
+        public String serviceType;
+
+        public String checkid;
+
+        public String checkName;
+
+        //http or sncp or mqtp
+        public String protocol;
+
+        //TCP or UDP
+        public String netProtocol;
+
+        @ConvertDisabled
+        public WeakReference<Service> serviceRef;
+
+        public InetSocketAddress address;
+
+        public boolean canceled;
+
+        public boolean submqtp;
+
+        public ClusterEntry(NodeServer ns, String protocol, Service service) {
+            this.serviceid = generateServiceId(ns, protocol, service);
+            this.serviceName = generateServiceName(ns, protocol, service);
+            this.checkid = generateCheckId(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();
+            if ("0.0.0.0".equals(host)) {
+                host = appAddress.getHostString();
+                addr = new InetSocketAddress(host, addr.getPort());
+            }
+            this.address = addr;
+            this.serviceRef = new WeakReference(service);
+            Server server = ns.getServer();
+            this.netProtocol = server instanceof SncpServer ? ((SncpServer) server).getNetprotocol() : Transport.DEFAULT_NETPROTOCOL;
+        }
+
+        @Override
+        public String toString() {
+            return JsonConvert.root().convertTo(this);
+        }
+    }
+}

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