From cb55bd36034b4c7c15e8b180d2de2a50c7a67402 Mon Sep 17 00:00:00 2001 From: yanzg Date: Fri, 18 May 2018 16:30:47 +0800 Subject: [PATCH] Create Project --- pom.xml | 132 +++++++++++ .../java/com/pangdly/annotation/Action.java | 16 ++ .../com/pangdly/annotation/ContentType.java | 27 +++ .../java/com/pangdly/annotation/Mapping.java | 24 ++ .../com/pangdly/annotation/PathParam.java | 20 ++ .../com/pangdly/annotation/RequestType.java | 27 +++ .../com/pangdly/annotation/ResponseType.java | 27 +++ .../arthas/codec/ArthasHttpRequest.java | 29 +++ .../arthas/codec/ArthasHttpRequestDecode.java | 13 ++ .../codec/ArthasHttpRequestDecodeHandler.java | 114 +++++++++ .../codec/ArthasHttpResponseEncode.java | 13 ++ .../ArthasHttpResponseEncodeHandler.java | 61 +++++ .../dispatcher/ArthasChannelInitializer.java | 37 +++ .../arthas/dispatcher/ArthasHttpHandler.java | 64 +++++ .../arthas/dispatcher/ArthasProcess.java | 14 ++ .../dispatcher/ArthasProcessHandler.java | 109 +++++++++ .../pangdly/arthas/dispatcher/DataCache.java | 22 ++ .../arthas/process/context/ActionContext.java | 75 ++++++ .../arthas/process/context/Context.java | 23 ++ .../context/XmlConfigFileActionContext.java | 55 +++++ .../arthas/process/factory/ActionFactory.java | 21 ++ .../arthas/process/factory/ActionWrapper.java | 29 +++ .../process/factory/AwareActionFactory.java | 69 ++++++ .../process/invocation/ActionInvoke.java | 41 ++++ .../arthas/process/invocation/Invoke.java | 11 + .../arthas/process/proxy/FactoryProxy.java | 53 +++++ .../pangdly/arthas/process/proxy/Proxy.java | 23 ++ .../ArthasHttpRequestSerializeHandler.java | 164 +++++++++++++ .../arthas/serialize/ArthasSerialize.java | 13 ++ .../serialize/convertor/ArrayConvertor.java | 56 +++++ .../serialize/convertor/ConvertProcessor.java | 178 ++++++++++++++ .../arthas/serialize/convertor/Convertor.java | 13 ++ .../serialize/convertor/ConvertorType.java | 83 +++++++ .../serialize/convertor/ModelConvertor.java | 82 +++++++ .../convertor/PrimitiveConvertor.java | 102 ++++++++ .../java/com/pangdly/constant/Constant.java | 51 ++++ .../pangdly/exception/ArthasException.java | 69 ++++++ .../java/com/pangdly/server/HttpServer.java | 88 +++++++ .../java/com/pangdly/util/ArthasUtil.java | 221 ++++++++++++++++++ src/main/java/com/pangdly/util/Assert.java | 17 ++ .../java/com/pangdly/util/SpringUtil.java | 28 +++ src/main/resources/log4j2.xml | 53 +++++ .../java/com/pangdly/Http/Netty/AppTest.java | 38 +++ target/Http.Netty-0.0.1-SNAPSHOT.jar | Bin 0 -> 62901 bytes target/classes/META-INF/MANIFEST.MF | 5 + .../com.pangdly/Http.Netty/pom.properties | 7 + .../maven/com.pangdly/Http.Netty/pom.xml | 132 +++++++++++ .../com/pangdly/annotation/Action.class | Bin 0 -> 498 bytes .../com/pangdly/annotation/ContentType.class | Bin 0 -> 1346 bytes .../com/pangdly/annotation/Mapping.class | Bin 0 -> 768 bytes .../com/pangdly/annotation/PathParam.class | Bin 0 -> 555 bytes .../com/pangdly/annotation/RequestType.class | Bin 0 -> 1376 bytes .../com/pangdly/annotation/ResponseType.class | Bin 0 -> 1316 bytes .../arthas/codec/ArthasHttpRequest.class | Bin 0 -> 4013 bytes .../codec/ArthasHttpRequestDecode.class | Bin 0 -> 285 bytes .../ArthasHttpRequestDecodeHandler.class | Bin 0 -> 5371 bytes .../codec/ArthasHttpResponseEncode.class | Bin 0 -> 223 bytes ...esponseEncodeHandler$ResponseHandler.class | Bin 0 -> 2503 bytes .../ArthasHttpResponseEncodeHandler.class | Bin 0 -> 3423 bytes .../dispatcher/ArthasChannelInitializer.class | Bin 0 -> 1872 bytes .../arthas/dispatcher/ArthasHttpHandler.class | Bin 0 -> 4033 bytes .../arthas/dispatcher/ArthasProcess.class | Bin 0 -> 272 bytes .../dispatcher/ArthasProcessHandler.class | Bin 0 -> 4042 bytes .../pangdly/arthas/dispatcher/DataCache.class | Bin 0 -> 781 bytes .../process/context/ActionContext.class | Bin 0 -> 5159 bytes .../arthas/process/context/Context.class | Bin 0 -> 614 bytes .../context/XmlConfigFileActionContext.class | Bin 0 -> 2932 bytes .../process/factory/ActionFactory.class | Bin 0 -> 672 bytes .../process/factory/ActionWrapper.class | Bin 0 -> 5143 bytes .../process/factory/AwareActionFactory.class | Bin 0 -> 4003 bytes .../process/invocation/ActionInvoke.class | Bin 0 -> 2046 bytes .../arthas/process/invocation/Invoke.class | Bin 0 -> 219 bytes .../arthas/process/proxy/FactoryProxy.class | Bin 0 -> 1992 bytes .../pangdly/arthas/process/proxy/Proxy.class | Bin 0 -> 482 bytes ...pRequestSerializeHandler$MethodParam.class | Bin 0 -> 4133 bytes .../ArthasHttpRequestSerializeHandler.class | Bin 0 -> 6521 bytes .../arthas/serialize/ArthasSerialize.class | Bin 0 -> 247 bytes .../serialize/convertor/ArrayConvertor.class | Bin 0 -> 2694 bytes .../convertor/ConvertProcessor.class | Bin 0 -> 6255 bytes .../serialize/convertor/Convertor.class | Bin 0 -> 324 bytes .../serialize/convertor/ConvertorType$1.class | Bin 0 -> 1345 bytes .../serialize/convertor/ConvertorType.class | Bin 0 -> 2014 bytes .../serialize/convertor/ModelConvertor.class | Bin 0 -> 4181 bytes .../convertor/PrimitiveConvertor.class | Bin 0 -> 3628 bytes .../com/pangdly/constant/Constant.class | Bin 0 -> 1987 bytes .../pangdly/exception/ArthasException.class | Bin 0 -> 2228 bytes .../com/pangdly/server/HttpServer.class | Bin 0 -> 4495 bytes .../classes/com/pangdly/util/ArthasUtil.class | Bin 0 -> 9355 bytes target/classes/com/pangdly/util/Assert.class | Bin 0 -> 577 bytes .../classes/com/pangdly/util/SpringUtil.class | Bin 0 -> 1220 bytes target/classes/log4j2.xml | 53 +++++ target/maven-archiver/pom.properties | 5 + .../compile/default-compile/createdFiles.lst | 0 .../compile/default-compile/inputFiles.lst | 40 ++++ .../default-testCompile/createdFiles.lst | 0 .../default-testCompile/inputFiles.lst | 1 + .../com/pangdly/Http/Netty/AppTest.class | Bin 0 -> 631 bytes 97 files changed, 2648 insertions(+) create mode 100644 pom.xml create mode 100644 src/main/java/com/pangdly/annotation/Action.java create mode 100644 src/main/java/com/pangdly/annotation/ContentType.java create mode 100644 src/main/java/com/pangdly/annotation/Mapping.java create mode 100644 src/main/java/com/pangdly/annotation/PathParam.java create mode 100644 src/main/java/com/pangdly/annotation/RequestType.java create mode 100644 src/main/java/com/pangdly/annotation/ResponseType.java create mode 100644 src/main/java/com/pangdly/arthas/codec/ArthasHttpRequest.java create mode 100644 src/main/java/com/pangdly/arthas/codec/ArthasHttpRequestDecode.java create mode 100644 src/main/java/com/pangdly/arthas/codec/ArthasHttpRequestDecodeHandler.java create mode 100644 src/main/java/com/pangdly/arthas/codec/ArthasHttpResponseEncode.java create mode 100644 src/main/java/com/pangdly/arthas/codec/ArthasHttpResponseEncodeHandler.java create mode 100644 src/main/java/com/pangdly/arthas/dispatcher/ArthasChannelInitializer.java create mode 100644 src/main/java/com/pangdly/arthas/dispatcher/ArthasHttpHandler.java create mode 100644 src/main/java/com/pangdly/arthas/dispatcher/ArthasProcess.java create mode 100644 src/main/java/com/pangdly/arthas/dispatcher/ArthasProcessHandler.java create mode 100644 src/main/java/com/pangdly/arthas/dispatcher/DataCache.java create mode 100644 src/main/java/com/pangdly/arthas/process/context/ActionContext.java create mode 100644 src/main/java/com/pangdly/arthas/process/context/Context.java create mode 100644 src/main/java/com/pangdly/arthas/process/context/XmlConfigFileActionContext.java create mode 100644 src/main/java/com/pangdly/arthas/process/factory/ActionFactory.java create mode 100644 src/main/java/com/pangdly/arthas/process/factory/ActionWrapper.java create mode 100644 src/main/java/com/pangdly/arthas/process/factory/AwareActionFactory.java create mode 100644 src/main/java/com/pangdly/arthas/process/invocation/ActionInvoke.java create mode 100644 src/main/java/com/pangdly/arthas/process/invocation/Invoke.java create mode 100644 src/main/java/com/pangdly/arthas/process/proxy/FactoryProxy.java create mode 100644 src/main/java/com/pangdly/arthas/process/proxy/Proxy.java create mode 100644 src/main/java/com/pangdly/arthas/serialize/ArthasHttpRequestSerializeHandler.java create mode 100644 src/main/java/com/pangdly/arthas/serialize/ArthasSerialize.java create mode 100644 src/main/java/com/pangdly/arthas/serialize/convertor/ArrayConvertor.java create mode 100644 src/main/java/com/pangdly/arthas/serialize/convertor/ConvertProcessor.java create mode 100644 src/main/java/com/pangdly/arthas/serialize/convertor/Convertor.java create mode 100644 src/main/java/com/pangdly/arthas/serialize/convertor/ConvertorType.java create mode 100644 src/main/java/com/pangdly/arthas/serialize/convertor/ModelConvertor.java create mode 100644 src/main/java/com/pangdly/arthas/serialize/convertor/PrimitiveConvertor.java create mode 100644 src/main/java/com/pangdly/constant/Constant.java create mode 100644 src/main/java/com/pangdly/exception/ArthasException.java create mode 100644 src/main/java/com/pangdly/server/HttpServer.java create mode 100644 src/main/java/com/pangdly/util/ArthasUtil.java create mode 100644 src/main/java/com/pangdly/util/Assert.java create mode 100644 src/main/java/com/pangdly/util/SpringUtil.java create mode 100644 src/main/resources/log4j2.xml create mode 100644 src/test/java/com/pangdly/Http/Netty/AppTest.java create mode 100644 target/Http.Netty-0.0.1-SNAPSHOT.jar create mode 100644 target/classes/META-INF/MANIFEST.MF create mode 100644 target/classes/META-INF/maven/com.pangdly/Http.Netty/pom.properties create mode 100644 target/classes/META-INF/maven/com.pangdly/Http.Netty/pom.xml create mode 100644 target/classes/com/pangdly/annotation/Action.class create mode 100644 target/classes/com/pangdly/annotation/ContentType.class create mode 100644 target/classes/com/pangdly/annotation/Mapping.class create mode 100644 target/classes/com/pangdly/annotation/PathParam.class create mode 100644 target/classes/com/pangdly/annotation/RequestType.class create mode 100644 target/classes/com/pangdly/annotation/ResponseType.class create mode 100644 target/classes/com/pangdly/arthas/codec/ArthasHttpRequest.class create mode 100644 target/classes/com/pangdly/arthas/codec/ArthasHttpRequestDecode.class create mode 100644 target/classes/com/pangdly/arthas/codec/ArthasHttpRequestDecodeHandler.class create mode 100644 target/classes/com/pangdly/arthas/codec/ArthasHttpResponseEncode.class create mode 100644 target/classes/com/pangdly/arthas/codec/ArthasHttpResponseEncodeHandler$ResponseHandler.class create mode 100644 target/classes/com/pangdly/arthas/codec/ArthasHttpResponseEncodeHandler.class create mode 100644 target/classes/com/pangdly/arthas/dispatcher/ArthasChannelInitializer.class create mode 100644 target/classes/com/pangdly/arthas/dispatcher/ArthasHttpHandler.class create mode 100644 target/classes/com/pangdly/arthas/dispatcher/ArthasProcess.class create mode 100644 target/classes/com/pangdly/arthas/dispatcher/ArthasProcessHandler.class create mode 100644 target/classes/com/pangdly/arthas/dispatcher/DataCache.class create mode 100644 target/classes/com/pangdly/arthas/process/context/ActionContext.class create mode 100644 target/classes/com/pangdly/arthas/process/context/Context.class create mode 100644 target/classes/com/pangdly/arthas/process/context/XmlConfigFileActionContext.class create mode 100644 target/classes/com/pangdly/arthas/process/factory/ActionFactory.class create mode 100644 target/classes/com/pangdly/arthas/process/factory/ActionWrapper.class create mode 100644 target/classes/com/pangdly/arthas/process/factory/AwareActionFactory.class create mode 100644 target/classes/com/pangdly/arthas/process/invocation/ActionInvoke.class create mode 100644 target/classes/com/pangdly/arthas/process/invocation/Invoke.class create mode 100644 target/classes/com/pangdly/arthas/process/proxy/FactoryProxy.class create mode 100644 target/classes/com/pangdly/arthas/process/proxy/Proxy.class create mode 100644 target/classes/com/pangdly/arthas/serialize/ArthasHttpRequestSerializeHandler$MethodParam.class create mode 100644 target/classes/com/pangdly/arthas/serialize/ArthasHttpRequestSerializeHandler.class create mode 100644 target/classes/com/pangdly/arthas/serialize/ArthasSerialize.class create mode 100644 target/classes/com/pangdly/arthas/serialize/convertor/ArrayConvertor.class create mode 100644 target/classes/com/pangdly/arthas/serialize/convertor/ConvertProcessor.class create mode 100644 target/classes/com/pangdly/arthas/serialize/convertor/Convertor.class create mode 100644 target/classes/com/pangdly/arthas/serialize/convertor/ConvertorType$1.class create mode 100644 target/classes/com/pangdly/arthas/serialize/convertor/ConvertorType.class create mode 100644 target/classes/com/pangdly/arthas/serialize/convertor/ModelConvertor.class create mode 100644 target/classes/com/pangdly/arthas/serialize/convertor/PrimitiveConvertor.class create mode 100644 target/classes/com/pangdly/constant/Constant.class create mode 100644 target/classes/com/pangdly/exception/ArthasException.class create mode 100644 target/classes/com/pangdly/server/HttpServer.class create mode 100644 target/classes/com/pangdly/util/ArthasUtil.class create mode 100644 target/classes/com/pangdly/util/Assert.class create mode 100644 target/classes/com/pangdly/util/SpringUtil.class create mode 100644 target/classes/log4j2.xml create mode 100644 target/maven-archiver/pom.properties create mode 100644 target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst create mode 100644 target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst create mode 100644 target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/createdFiles.lst create mode 100644 target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst create mode 100644 target/test-classes/com/pangdly/Http/Netty/AppTest.class diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..d74ffaf --- /dev/null +++ b/pom.xml @@ -0,0 +1,132 @@ + + 4.0.0 + + com.pangdly + Http.Netty + 0.0.1-SNAPSHOT + jar + + Http.Netty + http://maven.apache.org + + + UTF-8 + + 3.7.0 + 2.20.1 + 3.0.2 + 3.0.0 + 2.8.2 + 1.8 + UTF-8 + UTF-8 + + + + + junit + junit + 3.8.1 + test + + + + org.projectlombok + lombok + 1.16.16 + + + + commons-codec + commons-codec + 1.10 + + + + org.apache.httpcomponents + httpcore + 4.4.6 + + + + io.netty + netty-all + 4.1.15.Final + + + + org.springframework + spring-context + 4.3.3.RELEASE + + + + dom4j + dom4j + 1.6.1 + + + com.alibaba + fastjson + 1.2.38 + + + + org.apache.logging.log4j + log4j-api + 2.7 + + + org.apache.logging.log4j + log4j-core + 2.7 + + + org.apache.logging.log4j + log4j-web + 2.7 + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + ${maven.compiler.plugin.version} + + ${java.version} + ${java.version} + ${file.encoding} + + + + org.apache.maven.plugins + maven-surefire-plugin + ${maven.surefire.plugin.version} + + true + + + + org.apache.maven.plugins + maven-deploy-plugin + ${maven.deploy.plugin.version} + + + + + + + nexus-releases + Nexus Releases Repository + http://192.168.0.99:8081/repository/maven-releases/ + + + nexus-snapshots + Nexus Snapshots Repository + http://192.168.0.99:8081/repository/maven-snapshots/ + + + diff --git a/src/main/java/com/pangdly/annotation/Action.java b/src/main/java/com/pangdly/annotation/Action.java new file mode 100644 index 0000000..0667173 --- /dev/null +++ b/src/main/java/com/pangdly/annotation/Action.java @@ -0,0 +1,16 @@ +package com.pangdly.annotation; + +import java.lang.annotation.*; + +/** + * description: //TODO + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@Documented +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +public @interface Action { + String value() default "className"; +} diff --git a/src/main/java/com/pangdly/annotation/ContentType.java b/src/main/java/com/pangdly/annotation/ContentType.java new file mode 100644 index 0000000..004e718 --- /dev/null +++ b/src/main/java/com/pangdly/annotation/ContentType.java @@ -0,0 +1,27 @@ +package com.pangdly.annotation; + +/** + * description: //TODO + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public enum ContentType { + + JSON("application/json"); +// FORM("application/x-www-form-urlencoded"); + + private String value; + + ContentType(String value) { + this.value = value; + } + + public String getValue() { + return value; + } + + public void setValue(String value) { + this.value = value; + } +} diff --git a/src/main/java/com/pangdly/annotation/Mapping.java b/src/main/java/com/pangdly/annotation/Mapping.java new file mode 100644 index 0000000..5d7e2b6 --- /dev/null +++ b/src/main/java/com/pangdly/annotation/Mapping.java @@ -0,0 +1,24 @@ +package com.pangdly.annotation; + +import java.lang.annotation.*; + +/** + * description: //TODO + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@Target(ElementType.METHOD) +@Documented +@Retention(RetentionPolicy.RUNTIME) +public @interface Mapping { + + public String url() default "/"; + + public RequestType method() default RequestType.POST; + + public ResponseType response() default ResponseType.JSON; + + public String encode() default "UTF-8"; + +} diff --git a/src/main/java/com/pangdly/annotation/PathParam.java b/src/main/java/com/pangdly/annotation/PathParam.java new file mode 100644 index 0000000..6fb7b24 --- /dev/null +++ b/src/main/java/com/pangdly/annotation/PathParam.java @@ -0,0 +1,20 @@ +package com.pangdly.annotation; + +import java.lang.annotation.*; + +/** + * description: //TODO + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@Documented +@Target({ElementType.FIELD, ElementType.PARAMETER}) +@Retention(RetentionPolicy.RUNTIME) +public @interface PathParam { + + String name() default ""; + + boolean ness() default false; + +} diff --git a/src/main/java/com/pangdly/annotation/RequestType.java b/src/main/java/com/pangdly/annotation/RequestType.java new file mode 100644 index 0000000..7ccae16 --- /dev/null +++ b/src/main/java/com/pangdly/annotation/RequestType.java @@ -0,0 +1,27 @@ +package com.pangdly.annotation; + +/** + * description: //TODO + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public enum RequestType { + + GET("GET"), + POST("POST"); + + private String value; + + RequestType(String value) { + this.value = value; + } + + public String getValue() { + return this.value; + } + + public void setValue(String value) { + this.value = value; + } +} diff --git a/src/main/java/com/pangdly/annotation/ResponseType.java b/src/main/java/com/pangdly/annotation/ResponseType.java new file mode 100644 index 0000000..19328f5 --- /dev/null +++ b/src/main/java/com/pangdly/annotation/ResponseType.java @@ -0,0 +1,27 @@ +package com.pangdly.annotation; + +/** + * description: //TODO + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public enum ResponseType { + + JSON("application/json"), + // XML("text/xml"), +// TEXT("text/plain"), +// HTML("text/html"), + ERROR("text/plain"); + + ResponseType(String value) { + this.value = value; + } + + private String value; + + public String getValue() { + return value; + } + +} diff --git a/src/main/java/com/pangdly/arthas/codec/ArthasHttpRequest.java b/src/main/java/com/pangdly/arthas/codec/ArthasHttpRequest.java new file mode 100644 index 0000000..71e33ea --- /dev/null +++ b/src/main/java/com/pangdly/arthas/codec/ArthasHttpRequest.java @@ -0,0 +1,29 @@ +package com.pangdly.arthas.codec; + +import com.pangdly.annotation.RequestType; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.io.Serializable; +import java.util.List; +import java.util.Map; + +/** + * description: http request object + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@Data +@NoArgsConstructor +@AllArgsConstructor +public class ArthasHttpRequest implements Serializable { + + private static final long serialVersionUID = 191929180123034366L; + + private RequestType type; + private Map get; + private Map> post; + private String token; +} diff --git a/src/main/java/com/pangdly/arthas/codec/ArthasHttpRequestDecode.java b/src/main/java/com/pangdly/arthas/codec/ArthasHttpRequestDecode.java new file mode 100644 index 0000000..6d7e6bc --- /dev/null +++ b/src/main/java/com/pangdly/arthas/codec/ArthasHttpRequestDecode.java @@ -0,0 +1,13 @@ +package com.pangdly.arthas.codec; + +import com.pangdly.exception.ArthasException; + +/** + * description: http request decode interface + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public interface ArthasHttpRequestDecode { + ArthasHttpRequest process() throws ArthasException; +} diff --git a/src/main/java/com/pangdly/arthas/codec/ArthasHttpRequestDecodeHandler.java b/src/main/java/com/pangdly/arthas/codec/ArthasHttpRequestDecodeHandler.java new file mode 100644 index 0000000..d5fbb7c --- /dev/null +++ b/src/main/java/com/pangdly/arthas/codec/ArthasHttpRequestDecodeHandler.java @@ -0,0 +1,114 @@ +package com.pangdly.arthas.codec; + +import com.pangdly.arthas.dispatcher.DataCache; +import com.pangdly.annotation.Mapping; +import com.pangdly.annotation.RequestType; +import com.pangdly.constant.Constant; +import com.pangdly.exception.ArthasException; + +import io.netty.handler.codec.http.FullHttpRequest; +import io.netty.handler.codec.http.HttpRequest; +import io.netty.handler.codec.http.QueryStringDecoder; +import org.apache.commons.codec.CharEncoding; + +import java.lang.reflect.Method; +import java.nio.charset.Charset; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +/** + * description: http request decode handler implement + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public class ArthasHttpRequestDecodeHandler implements ArthasHttpRequestDecode { + + private final Method method; + + public ArthasHttpRequestDecodeHandler(Method method) { + this.method = method; + } + + @Override + public ArthasHttpRequest process() throws ArthasException { + + if (RequestType.GET.equals(type(method))) { + return get(); + } else { + return post(RequestType.POST); + } + } + + private ArthasHttpRequest get() throws ArthasException { + + HttpRequest request = (HttpRequest) DataCache.getData(); + if (null != paramsInUri(request.uri())) { + //Map params = paramsInUri(request.uri()); + String token = request.headers().get("token"); + return new ArthasHttpRequest(RequestType.GET, paramsInUri(request.uri()), null, token); + } else { + return new ArthasHttpRequest(); + } + } + + private ArthasHttpRequest post(RequestType type) throws ArthasException { + + FullHttpRequest request = (FullHttpRequest) DataCache.getData(); + //request.headers().add("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept,token"); + String token = request.headers().get("token"); + Map getParam = paramsInUri(request.uri()); + Map> postParam = new QueryStringDecoder(request.content().toString(Charset.forName(CharEncoding.UTF_8)), false).parameters(); + + return new ArthasHttpRequest(type, getParam, postParam, token); + } + + private RequestType type(Method method) throws ArthasException { + + HttpRequest request = (HttpRequest) DataCache.getData(); + String hm = request.method().name(); + String dm = method.getDeclaredAnnotation(Mapping.class).method().getValue(); + + //if (null == hm || null == dm || (!dm.equals("") && !dm.equals(hm))) { + if (null == hm || null == dm || dm.equals("")) { + throw new ArthasException(Constant.CODC_ERR_CODE, Constant.CODC_REQ_TYPE, ArthasException.APP_ERR); + } else if (RequestType.GET.getValue().equals(dm)) { + return RequestType.GET; + } else { + return RequestType.POST; + } + } + + private Map paramsInUri(String uri) throws ArthasException { + if (null != uri && uri.length() > 0) { + String params = uriSplit(uri); + return null == params ? null : paramSplit(params); + } else { + return null; + } + } + + private String uriSplit(String uri) throws ArthasException { + String[] arr = uri.split("\\?"); + if (arr.length != 2) { + return null; + } else { + return arr[1]; + } + } + + private Map paramSplit(String params) { + Map map = new HashMap<>(); + String[] arr = params.split("&"); + Arrays.stream(arr).forEach((param) -> { + String[] pa = param.split("="); + if (pa.length == 2) { + map.put(pa[0], pa[1]); + } + }); + return map; + } + +} diff --git a/src/main/java/com/pangdly/arthas/codec/ArthasHttpResponseEncode.java b/src/main/java/com/pangdly/arthas/codec/ArthasHttpResponseEncode.java new file mode 100644 index 0000000..b56fc57 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/codec/ArthasHttpResponseEncode.java @@ -0,0 +1,13 @@ +package com.pangdly.arthas.codec; + +import io.netty.handler.codec.http.FullHttpResponse; + +/** + * description: http response encode interface + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public interface ArthasHttpResponseEncode { + FullHttpResponse process(); +} diff --git a/src/main/java/com/pangdly/arthas/codec/ArthasHttpResponseEncodeHandler.java b/src/main/java/com/pangdly/arthas/codec/ArthasHttpResponseEncodeHandler.java new file mode 100644 index 0000000..4de4ca3 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/codec/ArthasHttpResponseEncodeHandler.java @@ -0,0 +1,61 @@ +package com.pangdly.arthas.codec; + +import com.pangdly.annotation.ResponseType; +import com.pangdly.constant.Constant; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import io.netty.handler.codec.http.DefaultFullHttpResponse; +import io.netty.handler.codec.http.FullHttpResponse; +import io.netty.handler.codec.http.HttpResponseStatus; +import io.netty.handler.codec.http.HttpVersion; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.extern.log4j.Log4j2; + +/** + * description: http response encode implement + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@Log4j2 +@Data +@AllArgsConstructor +public class ArthasHttpResponseEncodeHandler implements ArthasHttpResponseEncode { + + private String data; + private ResponseType type; + + @Override + public FullHttpResponse process() { + + return ResponseHandler.handle(data, type); + } + + private static class ResponseHandler { + + static FullHttpResponse handle(String data, ResponseType type) { + if (null == data || null == type) { + data = "server error !!!"; + type = ResponseType.ERROR; + } + log.info("ArthasHttpResponseEncodeHandler.ResponseHandler.handle()->data:{}", data); + ByteBuf buf = Unpooled.wrappedBuffer(data.getBytes()); + log.info("ArthasHttpResponseEncodeHandler.ResponseHandler.handle()->buf:{}", buf); + FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, buf); + response.headers() + .add(Constant.CONTENT_TYPE, type.getValue()) + .add(Constant.CONTENT_LENGTH, String.valueOf(buf.readableBytes())); + + log.info("ArthasHttpResponseEncodeHandler.ResponseHandler.handle()->response:{}", response); + + return response; + } + } + + public static void main(String[] args) { + ArthasHttpResponseEncodeHandler handler = new ArthasHttpResponseEncodeHandler("nihao", ResponseType.JSON); + log.info(ResponseType.JSON.getValue()); + log.info(handler.process()); + } +} diff --git a/src/main/java/com/pangdly/arthas/dispatcher/ArthasChannelInitializer.java b/src/main/java/com/pangdly/arthas/dispatcher/ArthasChannelInitializer.java new file mode 100644 index 0000000..edc1d84 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/dispatcher/ArthasChannelInitializer.java @@ -0,0 +1,37 @@ +package com.pangdly.arthas.dispatcher; + +import io.netty.channel.ChannelInitializer; +import io.netty.channel.ChannelPipeline; +import io.netty.channel.socket.SocketChannel; +import io.netty.handler.codec.http.HttpObjectAggregator; +import io.netty.handler.codec.http.HttpServerCodec; +import io.netty.handler.codec.http.HttpServerExpectContinueHandler; +import io.netty.handler.ssl.SslContext; + +/** + * description: arthas channel initializer, initialize netty channel + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public class ArthasChannelInitializer extends ChannelInitializer { + + private final SslContext ssl; + + public ArthasChannelInitializer(SslContext ssl) { + this.ssl = ssl; + } + + @Override + protected void initChannel(SocketChannel channel) { + + ChannelPipeline pipeline = channel.pipeline(); + if (null != ssl) { + pipeline.addLast(ssl.newHandler(channel.alloc())); + } + pipeline.addLast(new HttpServerCodec()); + pipeline.addLast(new HttpObjectAggregator(1024 * 1024 * 64)); + pipeline.addLast(new HttpServerExpectContinueHandler()); + pipeline.addLast(new ArthasHttpHandler()); + } +} diff --git a/src/main/java/com/pangdly/arthas/dispatcher/ArthasHttpHandler.java b/src/main/java/com/pangdly/arthas/dispatcher/ArthasHttpHandler.java new file mode 100644 index 0000000..4f42ee4 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/dispatcher/ArthasHttpHandler.java @@ -0,0 +1,64 @@ +package com.pangdly.arthas.dispatcher; + +import com.pangdly.constant.Constant; + +import io.netty.channel.ChannelFutureListener; +import io.netty.channel.ChannelHandlerContext; +import io.netty.channel.ChannelInboundHandlerAdapter; +import io.netty.handler.codec.http.FullHttpResponse; +import io.netty.handler.codec.http.HttpRequest; +import io.netty.handler.codec.http.HttpUtil; +import lombok.extern.log4j.Log4j2; + +/** + * description: Arthas channel handler, recieve request and response result + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@Log4j2 +public class ArthasHttpHandler extends ChannelInboundHandlerAdapter { + + @Override + public void channelReadComplete(ChannelHandlerContext ctx) { + ctx.flush(); + } + + @Override + public void channelRead(ChannelHandlerContext ctx, Object msg) { + + long start = System.currentTimeMillis(); + + if (msg instanceof HttpRequest) { + + // initialize channel and request + // cache the data to ThreadLocal + // + HttpRequest request = (HttpRequest) msg; + DataCache.setData(msg); + FullHttpResponse response = new ArthasProcessHandler().process(); + + boolean keepAlive = HttpUtil.isKeepAlive(request); + if (!keepAlive) { + ctx.write(response).addListener(ChannelFutureListener.CLOSE); + } else { + response.headers().set("Access-Control-Allow-Origin", "*"); + response.headers().set("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept,token"); + response.headers().set(Constant.CONNECTION, Constant.KEEP_ALIVE); + ctx.write(response); + } + log.info("---------------------------------------------------------------"); + log.info("READ: {}", ctx.channel()); + log.info("URL: {}", request.uri().split("\\?")[0]); + log.info("RESPONSE: {}", response); + log.info("READ: complete | COST: {} | RESPONSE: {}", System.currentTimeMillis() - start, response.status()); + log.info("---------------------------------------------------------------\n\n"); + } + } + + @Override + public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { + log.error("netty handler http request occur error, excepion: {}", cause.getStackTrace().toString()); + ctx.close(); + } +} diff --git a/src/main/java/com/pangdly/arthas/dispatcher/ArthasProcess.java b/src/main/java/com/pangdly/arthas/dispatcher/ArthasProcess.java new file mode 100644 index 0000000..a40d20d --- /dev/null +++ b/src/main/java/com/pangdly/arthas/dispatcher/ArthasProcess.java @@ -0,0 +1,14 @@ +package com.pangdly.arthas.dispatcher; + +import com.pangdly.exception.ArthasException; +import io.netty.handler.codec.http.FullHttpResponse; + +/** + * description: http request handle process interface + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public interface ArthasProcess { + FullHttpResponse process() throws ArthasException; +} diff --git a/src/main/java/com/pangdly/arthas/dispatcher/ArthasProcessHandler.java b/src/main/java/com/pangdly/arthas/dispatcher/ArthasProcessHandler.java new file mode 100644 index 0000000..2677d78 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/dispatcher/ArthasProcessHandler.java @@ -0,0 +1,109 @@ +package com.pangdly.arthas.dispatcher; + +import com.pangdly.arthas.codec.ArthasHttpResponseEncodeHandler; +import com.pangdly.annotation.ResponseType; +import com.pangdly.constant.Constant; +import com.pangdly.exception.ArthasException; +import com.pangdly.arthas.process.context.Context; +import com.pangdly.arthas.process.context.XmlConfigFileActionContext; +import com.pangdly.arthas.process.factory.ActionWrapper; +import com.pangdly.arthas.process.proxy.Proxy; +import io.netty.handler.codec.http.FullHttpResponse; +import io.netty.handler.codec.http.HttpRequest; +import lombok.extern.log4j.Log4j2; + +/** + * description: http request handler process implement + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@Log4j2 +@SuppressWarnings("rawtypes") +public class ArthasProcessHandler implements ArthasProcess { + + private static Context context; + private String path; + private String name; + + public void init(String name) { + name = null == name ? "" : name; + context = new XmlConfigFileActionContext(name); + } + + @Override + public FullHttpResponse process() { + + // if context is null, initialize it + // + if (null == context) { + name = null == name ? "" : name; + context = new XmlConfigFileActionContext(name); + } + + // handle request + // + String result = ""; + ResponseType type = null; + HttpRequest request = (HttpRequest) DataCache.getData(); + path = request.uri(); + + try { + // handle request + // + result = proxy().execute(); + log.info("ArthasProcessHandler()----result({})", result); + type = wrapper().getResponse(); + //handle response and return + // + return new ArthasHttpResponseEncodeHandler(result, type).process(); + } catch (ArthasException e) { + log.error("handle http request throw exception, cause: {}", e.toString()); + + // initialize error response and return + // + result = Constant.ERR_MSG; + type = ResponseType.ERROR; + return new ArthasHttpResponseEncodeHandler(result, type).process(); + } catch (Exception e) { + log.error("handle http request throw exception, cause: {}", e.toString()); + + // initialize error response and return + // + result = Constant.ERR_MSG; + type = ResponseType.ERROR; + return new ArthasHttpResponseEncodeHandler(result, type).process(); + } finally { + log.info("------------------------------------------------------------"); + log.info("TYPE: {}", type); + log.info("CONTENT: {}", result); + } + } + + + private Proxy proxy() throws ArthasException { + Proxy proxy = context.getProxy(wrapper()); + if (null == proxy) { + throw new ArthasException(Constant.DISP_ERR_CODE, Constant.DISP_PROX_MSG, ArthasException.APP_ERR); + } + return proxy; + } + + private ActionWrapper wrapper() throws ArthasException { + + if (null == path || path.length() <= 0) { + throw new ArthasException(Constant.DISP_ERR_CODE, Constant.DISP_WRAP_MSG, ArthasException.APP_ERR); + } + ActionWrapper wrapper; + try { + wrapper = context.getWrapper(path); + } catch (Exception e) { + throw new ArthasException(Constant.DISP_ERR_CODE, Constant.DISP_WRAP_MSG, ArthasException.APP_ERR); + } + if (null == wrapper) { + throw new ArthasException(Constant.DISP_ERR_CODE, Constant.DISP_WRAP_MSG, ArthasException.APP_ERR); + } + return wrapper; + } + +} diff --git a/src/main/java/com/pangdly/arthas/dispatcher/DataCache.java b/src/main/java/com/pangdly/arthas/dispatcher/DataCache.java new file mode 100644 index 0000000..0988585 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/dispatcher/DataCache.java @@ -0,0 +1,22 @@ +package com.pangdly.arthas.dispatcher; + +/** + * description: ThreadLocal object + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public class DataCache { + + private static final ThreadLocal localData = new ThreadLocal<>(); + + static void setData(Object obj) { + localData.set(obj); + } + + public static Object getData() { + return localData.get(); + } + + +} diff --git a/src/main/java/com/pangdly/arthas/process/context/ActionContext.java b/src/main/java/com/pangdly/arthas/process/context/ActionContext.java new file mode 100644 index 0000000..0225770 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/process/context/ActionContext.java @@ -0,0 +1,75 @@ +package com.pangdly.arthas.process.context; + +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.function.Predicate; + +import com.pangdly.arthas.process.factory.ActionWrapper; +import com.pangdly.annotation.Mapping; +import com.pangdly.util.ArthasUtil; +import com.pangdly.util.SpringUtil; + +import lombok.extern.log4j.Log4j2; + +/** + * description: context base initializer + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@Log4j2 +@SuppressWarnings("rawtypes") +abstract class ActionContext { + + @SuppressWarnings("unchecked") + Map> wrapperMap(List names) { + + // get the value of class whole name in package + // set the value into list + // + List list = new ArrayList<>(); + names.forEach(name -> ArthasUtil.findFilesInPackage(name, list)); + log.info("the class file list is {}", list); + + // init the action wrapper of the classes + // set the value into the map + // + Map> map = new HashMap<>(); + list.forEach((String entry) -> { + try { + Class clazz = Class.forName(entry); + Method[] methods = clazz.getDeclaredMethods(); + if (null == methods || methods.length <= 0) { + return; + } + Predicate predicate = m -> (null == m || null == m.getAnnotation(Mapping.class)) ? false : true; + Arrays.stream(methods).filter(predicate).forEach((Method method) -> { + try { + ActionWrapper wrapper = new ActionWrapper(); + if (null != SpringUtil.getContext()) { + wrapper.setAction(SpringUtil.getBean(clazz)); + } else { + wrapper.setAction(clazz.newInstance()); + } + wrapper.setName(clazz.getName()); + wrapper.setTarget(method.getAnnotation(Mapping.class).url()); + wrapper.setType(method.getAnnotation(Mapping.class).method()); + wrapper.setResponse(method.getAnnotation(Mapping.class).response()); + wrapper.setMethod(method); + map.put(method.getAnnotation(Mapping.class).url(), wrapper); + } catch (Exception e) { + log.error("Server error!!! {}", e); + } + }); + } catch (Exception e) { + e.printStackTrace(); + } + }); + return map; + } + +} diff --git a/src/main/java/com/pangdly/arthas/process/context/Context.java b/src/main/java/com/pangdly/arthas/process/context/Context.java new file mode 100644 index 0000000..afd8084 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/process/context/Context.java @@ -0,0 +1,23 @@ +package com.pangdly.arthas.process.context; + +import com.pangdly.arthas.process.factory.ActionWrapper; +import com.pangdly.arthas.process.proxy.Proxy; + +/** + * description: context initialize interface + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@SuppressWarnings("rawtypes") +public interface Context { + + Proxy getProxy(ActionWrapper action); + + ActionWrapper getWrapper(String path) throws Exception; + + Object getAction(String name) throws Exception; + + Object getAction(String name, Class type) throws Exception; + +} diff --git a/src/main/java/com/pangdly/arthas/process/context/XmlConfigFileActionContext.java b/src/main/java/com/pangdly/arthas/process/context/XmlConfigFileActionContext.java new file mode 100644 index 0000000..0144d0c --- /dev/null +++ b/src/main/java/com/pangdly/arthas/process/context/XmlConfigFileActionContext.java @@ -0,0 +1,55 @@ +package com.pangdly.arthas.process.context; + +import com.pangdly.arthas.process.factory.ActionFactory; +import com.pangdly.arthas.process.factory.ActionWrapper; +import com.pangdly.arthas.process.factory.AwareActionFactory; +import com.pangdly.arthas.process.invocation.ActionInvoke; +import com.pangdly.arthas.process.proxy.FactoryProxy; +import com.pangdly.arthas.process.proxy.Proxy; +import com.pangdly.exception.ArthasException; +import com.pangdly.util.ArthasUtil; +import com.pangdly.util.Assert; + +import lombok.extern.log4j.Log4j2; + +/** + * description: initalize context from xml config file + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@Log4j2 +@SuppressWarnings("rawtypes") +public class XmlConfigFileActionContext extends ActionContext implements Context { + + private ActionFactory factory; + + public XmlConfigFileActionContext(String name) { + Assert.notNull(name, "file name cannot be null !!!"); + factory = new AwareActionFactory(wrapperMap(ArthasUtil.parsePackage(name))); + log.info("action factory is: {}", factory.toString()); + } + + @SuppressWarnings("unchecked") + @Override + public Proxy getProxy(ActionWrapper action) { + Proxy proxy = new FactoryProxy(action); + proxy.setInvoke(new ActionInvoke(proxy)); + return proxy; + } + + @Override + public ActionWrapper getWrapper(String path) throws ArthasException { + return factory.getWrapper(path); + } + + @Override + public Object getAction(String name) throws ArthasException { + return factory.getAction(name); + } + + @Override + public Object getAction(String name, Class clazz) throws ArthasException { + return factory.getAction(name, clazz); + } +} diff --git a/src/main/java/com/pangdly/arthas/process/factory/ActionFactory.java b/src/main/java/com/pangdly/arthas/process/factory/ActionFactory.java new file mode 100644 index 0000000..516eb4b --- /dev/null +++ b/src/main/java/com/pangdly/arthas/process/factory/ActionFactory.java @@ -0,0 +1,21 @@ +package com.pangdly.arthas.process.factory; + +import com.pangdly.exception.ArthasException; + +/** + * description: action factory interface + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public interface ActionFactory { + + ActionWrapper getWrapper(String path) throws ArthasException; + + Object getAction(String name) throws ArthasException; + + T getAction(String name, Class clazz) throws ArthasException; + + boolean containsAction(String name); + +} diff --git a/src/main/java/com/pangdly/arthas/process/factory/ActionWrapper.java b/src/main/java/com/pangdly/arthas/process/factory/ActionWrapper.java new file mode 100644 index 0000000..a22f7f9 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/process/factory/ActionWrapper.java @@ -0,0 +1,29 @@ +package com.pangdly.arthas.process.factory; + +import com.pangdly.annotation.RequestType; +import com.pangdly.annotation.ResponseType; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.lang.reflect.Method; + +/** + * description: action wrapper + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@Data +@NoArgsConstructor +@AllArgsConstructor +public class ActionWrapper { + + private T action; + private Method method; + private String name; + private String target; + private RequestType type; + private ResponseType response; + +} diff --git a/src/main/java/com/pangdly/arthas/process/factory/AwareActionFactory.java b/src/main/java/com/pangdly/arthas/process/factory/AwareActionFactory.java new file mode 100644 index 0000000..1ae5a97 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/process/factory/AwareActionFactory.java @@ -0,0 +1,69 @@ +package com.pangdly.arthas.process.factory; + +import java.util.Map; + +import com.pangdly.constant.Constant; +import com.pangdly.exception.ArthasException; +import com.pangdly.util.Assert; + +/** + * description: action wrapper factory + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public class AwareActionFactory implements ActionFactory { + + private Map> actions; + + public AwareActionFactory(Map> actions) { + Assert.notNull(actions, "Map cannot be null !!!"); + this.actions = actions; + } + + @Override + public ActionWrapper getWrapper(String path) throws ArthasException { + for (String key : actions.keySet()) { + if (path.contains(key)) { + return actions.get(key); + } + } + throw new ArthasException(Constant.PROC_ERR_CODE, Constant.PROC_NO_WRAP, ArthasException.APP_ERR); + } + + @Override + public Object getAction(String name) throws ArthasException { + if (containsAction(name)) { + return actions.get(name).getAction(); + } else { + throw new ArthasException(Constant.PROC_ERR_CODE, Constant.PROC_NO_WRAP, ArthasException.APP_ERR); + } + } + + @SuppressWarnings("unchecked") + @Override + public T getAction(String name, Class clazz) throws ArthasException { + if (containsAction(name)) { + ActionWrapper wrapper = (ActionWrapper) actions.get(name); + if (clazz.getName().equals(wrapper.getName())) { + return wrapper.getAction(); + } else { + throw new ArthasException(Constant.PROC_ERR_CODE, Constant.PROC_NO_WRAP, ArthasException.APP_ERR); + } + } else { + throw new ArthasException(Constant.PROC_ERR_CODE, Constant.PROC_NO_WRAP, ArthasException.APP_ERR); + } + } + + @Override + public boolean containsAction(String name) { + return null != actions && actions.keySet().stream().filter(key -> key.equals(name)).count() > 0; + } + + @Override + public String toString() { + return "AwareActionFactory{" + + "actions=" + actions + + '}'; + } +} diff --git a/src/main/java/com/pangdly/arthas/process/invocation/ActionInvoke.java b/src/main/java/com/pangdly/arthas/process/invocation/ActionInvoke.java new file mode 100644 index 0000000..2c63b1c --- /dev/null +++ b/src/main/java/com/pangdly/arthas/process/invocation/ActionInvoke.java @@ -0,0 +1,41 @@ +package com.pangdly.arthas.process.invocation; + +import com.pangdly.arthas.codec.ArthasHttpRequestDecodeHandler; +import com.pangdly.constant.Constant; +import com.pangdly.exception.ArthasException; +import com.pangdly.util.Assert; +import com.pangdly.arthas.process.proxy.Proxy; +import com.pangdly.arthas.serialize.ArthasHttpRequestSerializeHandler; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +/** + * description: action invoker implements interface + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@SuppressWarnings("rawtypes") +public class ActionInvoke implements Invoke { + + private Proxy proxy; + + public ActionInvoke(Proxy proxy) { + Assert.notNull(proxy, "FactoryProxy cannot be null !!!"); + this.proxy = proxy; + proxy.setInvoke(this); + } + + @Override + public String invoke() throws ArthasException { + + try { + Method method = proxy.getMethod(); + Object[] target = new ArthasHttpRequestSerializeHandler(method, new ArthasHttpRequestDecodeHandler(method).process()).handle(); + return (String) proxy.getMethod().invoke(proxy.getAction(), target); + } catch (IllegalAccessException | InvocationTargetException e) { + throw new ArthasException(Constant.PROC_ERR_CODE, Constant.PROC_ERR_INVOK, ArthasException.APP_ERR); + } + } +} diff --git a/src/main/java/com/pangdly/arthas/process/invocation/Invoke.java b/src/main/java/com/pangdly/arthas/process/invocation/Invoke.java new file mode 100644 index 0000000..dfcd30b --- /dev/null +++ b/src/main/java/com/pangdly/arthas/process/invocation/Invoke.java @@ -0,0 +1,11 @@ +package com.pangdly.arthas.process.invocation; + +/** + * description: invoke action interface + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public interface Invoke { + String invoke() throws Exception; +} diff --git a/src/main/java/com/pangdly/arthas/process/proxy/FactoryProxy.java b/src/main/java/com/pangdly/arthas/process/proxy/FactoryProxy.java new file mode 100644 index 0000000..df09962 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/process/proxy/FactoryProxy.java @@ -0,0 +1,53 @@ +package com.pangdly.arthas.process.proxy; + +import java.lang.reflect.Method; + +import com.pangdly.arthas.process.factory.ActionWrapper; +import com.pangdly.arthas.process.invocation.ActionInvoke; +import com.pangdly.exception.ArthasException; +import com.pangdly.util.Assert; + +/** + * description: factory proxy implement + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@SuppressWarnings("rawtypes") +public class FactoryProxy implements Proxy { + + private ActionWrapper wrapper; + private ActionInvoke invoke; + + public FactoryProxy(ActionWrapper wrapper) { + Assert.notNull(wrapper, "ActionWrapper cannot be null !!!"); + this.wrapper = wrapper; + } + + @Override + public T getAction() { + return wrapper.getAction(); + } + + @Override + public Method getMethod() { + return wrapper.getMethod(); + } + + @Override + public void setInvoke(ActionInvoke invoke) { + this.invoke = invoke; + } + + @Override + public String execute() { + try { + return invoke.invoke(); + } catch (ArthasException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + return "FactoryProxy.execute error"; + } +} diff --git a/src/main/java/com/pangdly/arthas/process/proxy/Proxy.java b/src/main/java/com/pangdly/arthas/process/proxy/Proxy.java new file mode 100644 index 0000000..f0bebb9 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/process/proxy/Proxy.java @@ -0,0 +1,23 @@ +package com.pangdly.arthas.process.proxy; + +import com.pangdly.exception.ArthasException; +import com.pangdly.arthas.process.invocation.ActionInvoke; + +import java.lang.reflect.Method; + +/** + * description: proxy interface + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public interface Proxy { + + T getAction(); + + Method getMethod(); + + void setInvoke(ActionInvoke invoke); + + String execute() throws ArthasException; +} diff --git a/src/main/java/com/pangdly/arthas/serialize/ArthasHttpRequestSerializeHandler.java b/src/main/java/com/pangdly/arthas/serialize/ArthasHttpRequestSerializeHandler.java new file mode 100644 index 0000000..4511e36 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/serialize/ArthasHttpRequestSerializeHandler.java @@ -0,0 +1,164 @@ +package com.pangdly.arthas.serialize; + +import com.pangdly.arthas.codec.ArthasHttpRequest; +import com.pangdly.annotation.PathParam; +import com.pangdly.constant.Constant; +import com.pangdly.exception.ArthasException; +import com.pangdly.util.Assert; +import com.pangdly.arthas.serialize.convertor.*; +import lombok.AllArgsConstructor; +import lombok.Data; + +import java.lang.reflect.Method; +import java.lang.reflect.Parameter; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +/** + * description: http request serialize handeler implements ArthasSerialize + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public class ArthasHttpRequestSerializeHandler implements ArthasSerialize { + + private final Method method; + private final ArthasHttpRequest request; + + public ArthasHttpRequestSerializeHandler(Method method, ArthasHttpRequest request) { + Assert.notNull(method, "Method cannot be null !!!"); + Assert.notNull(request, "ArthasHttpRequest cannot be null !!!"); + this.method = method; + this.request = request; + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @Override + public Object[] handle() throws ArthasException { + + // get method parameters count + // intialize Object array + // + List params = methodParam(method); + Object[] target = new Object[params.size()]; + + if (params.size() > 0) { + for (int i = 0; i < params.size(); i++) { + + // get method parameter object from list + // + + MethodParam param = params.get(i); + + if (param.getIsPath()) { + + // POST + if(null != request.getPost() && !request.getPost().isEmpty()) { + String v = ""; + if("data".equals(param.getName())) { + v = request.getPost().keySet().toString(); + Convertor conv = new PrimitiveConvertor<>(v, param.getClazz()); + target[i] = conv.convert(); + } else if("token".equals(param.getName())){ + target[i] = request.getToken(); + }else { + List vlist = request.getPost().get(param.getName()); + for (String string : vlist) { + Convertor conv = new PrimitiveConvertor<>(string, param.getClazz()); + target[i] = conv.convert(); + } + } + } + + // GET + // uri contains parameters + // + if (null != request.getGet() && !request.getGet().isEmpty()) { + String v = request.getGet().get(param.getName()); + + if (param.getNess() && (null == v || v.length() <= 0)) { + throw new ArthasException(Constant.SERI_ERR_CODE, Constant.SERI_NESS_MSG, + ArthasException.APP_ERR); + } + if (null != v && v.length() > 0) { + Convertor conv = new PrimitiveConvertor<>(v, param.getClazz()); + target[i] = conv.convert(); + } + } + } else { + + // post content contains parameters + // convert array to parameter + // + if (ConvertProcessor.isArray(param.getClazz())) { + List v = request.getPost().get(param.getName()); + if (null != v && v.size() > 0) { + Convertor conv = new ArrayConvertor<>(v, param.getClazz()); + target[i] = conv.convert(); + } + } + // convert model to parmeter + // + else { + Convertor conv = new ModelConvertor(request.getPost(), param.getClazz()); + target[i] = conv.convert(); + } + } + } + } + return target; + } + + private List methodParam(Method method) { + + // initialize params list, if method is null, return blank list directly + // + List params = new ArrayList<>(); + if (null == method) { + return params; + } + + Arrays.stream(method.getParameters()) + .forEach(p -> { + PathParam xObject = (PathParam) p.getDeclaredAnnotationsByType(PathParam.class)[0]; + System.out.println(xObject); + if (null != p.getDeclaredAnnotationsByType(PathParam.class) && p.getDeclaredAnnotationsByType(PathParam.class).length > 0) { + // add uri parameter + params.add(new MethodParam(getAnno(p).name(), getAnno(p).ness(), p.getType())); + } else { + // add post parameter + params.add(new MethodParam(p.getType(), false)); + } + }); + return params; + } + + private PathParam getAnno(Parameter parameter) { + return parameter.getAnnotation(PathParam.class); + } + + // inner class + // model for parameter + // + @Data + @AllArgsConstructor + private static class MethodParam { + private String name; + private Boolean ness; + private Class clazz; + private Boolean isPath; + + MethodParam(Class clazz, Boolean isPath) { + this.clazz = clazz; + this.isPath = isPath; + } + + MethodParam(String name, Boolean ness, Class clazz) { + this.name = name; + this.ness = ness; + this.clazz = clazz; + this.isPath = true; + } + } +} diff --git a/src/main/java/com/pangdly/arthas/serialize/ArthasSerialize.java b/src/main/java/com/pangdly/arthas/serialize/ArthasSerialize.java new file mode 100644 index 0000000..a505b54 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/serialize/ArthasSerialize.java @@ -0,0 +1,13 @@ +package com.pangdly.arthas.serialize; + +import com.pangdly.exception.ArthasException; + +/** + * description: arthas serialize interface + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public interface ArthasSerialize { + Object[] handle() throws ArthasException; +} diff --git a/src/main/java/com/pangdly/arthas/serialize/convertor/ArrayConvertor.java b/src/main/java/com/pangdly/arthas/serialize/convertor/ArrayConvertor.java new file mode 100644 index 0000000..933f826 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/serialize/convertor/ArrayConvertor.java @@ -0,0 +1,56 @@ +package com.pangdly.arthas.serialize.convertor; + +import java.lang.reflect.Array; +import java.util.List; + +import com.pangdly.constant.Constant; +import com.pangdly.exception.ArthasException; +import com.pangdly.util.Assert; + +/** + * description: array convertor, implements interface Convertor + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@SuppressWarnings("rawtypes") +public class ArrayConvertor implements Convertor { + + private List v; + private Class c; + + private T target; + + public ArrayConvertor(List v, Class c) throws ArthasException { + Assert.notNull(v, "the value can not be null !!!"); + Assert.notNull(c, "the target type can not be null !!!"); + this.v = v; + this.c = c; + conv(); + } + + @SuppressWarnings("unchecked") + private void conv() throws ArthasException { + if (!ConvertProcessor.isArray(c)) { + throw new ArthasException(Constant.CONV_ERR_CODE, Constant.CONV_NOT_ARRAY, ArthasException.APP_ERR); + } + + Class type = c.getComponentType(); + int length = v.size(); + Object o = Array.newInstance(type, length); + for (int i = 0; i < length; i++) { + if (type.equals(String.class)) { + Array.set(o, i, v.get(i)); + } else { + Convertor con = new PrimitiveConvertor<>(v.get(i), type); + Array.set(o, i, con.convert()); + } + } + target = (T) o; + } + + @Override + public T convert() throws ArthasException { + return target; + } +} diff --git a/src/main/java/com/pangdly/arthas/serialize/convertor/ConvertProcessor.java b/src/main/java/com/pangdly/arthas/serialize/convertor/ConvertProcessor.java new file mode 100644 index 0000000..98dcbda --- /dev/null +++ b/src/main/java/com/pangdly/arthas/serialize/convertor/ConvertProcessor.java @@ -0,0 +1,178 @@ +package com.pangdly.arthas.serialize.convertor; + + +import com.pangdly.constant.Constant; +import com.pangdly.exception.ArthasException; +import com.pangdly.util.Assert; +import lombok.extern.log4j.Log4j2; + +import java.math.BigDecimal; + +/** + * description: convertor executor + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@Log4j2 +@SuppressWarnings("rawtypes") +public class ConvertProcessor implements Convertor { + + private Class clazz; + private Object value; + + private T t; + + public ConvertProcessor(Class clazz, Object value) throws ArthasException { + Assert.notNull(clazz, "Class clazz can not be null !!!"); + Assert.notNull(value, "Map map can not be null !!!"); + this.clazz = clazz; + this.value = value; + conv(); + } + + private void conv() throws ArthasException { + long start = System.currentTimeMillis(); + switch (classType()) { + case ConvertorType.PRIMITIVE: + convToPrimitive(); + break; + case ConvertorType.ARRAY: + t = null; + break; + case ConvertorType.LOCAL: + // TODO + break; + case ConvertorType.ILLEGAL: + throw new ArthasException("123", "123", ArthasException.APP_ERR); + } + log.debug("conv cost {}", System.currentTimeMillis() - start); + } + + private int classType() { + return type(clazz); + } + + private void convToPrimitive() throws ArthasException { + if (isInt()) { + convToInt(); + } else if (isLong()) { + convToLong(); + } else if (isDouble()) { + convToDouble(); + } else if (isBoolean()) { + convToBoolean(); + } else if (isDecimal()) { + convToDecimal(); + } else if (isString()) { + value(); + } else { + throw new ArthasException(Constant.CONV_ERR_CODE, Constant.CONV_NOT_PRIMITIVE, ArthasException.APP_ERR); + } + } + + private int type(Class clazz) { + try { + if (isPrimitive(clazz)) { + return ConvertorType.PRIMITIVE; + } else if (isArray(clazz)) { + return ConvertorType.ARRAY; + } else if (isIllegal(clazz)) { + return ConvertorType.ILLEGAL; + } else { + return ConvertorType.LOCAL; + } + } catch (Exception e) { + log.error("verify type occur excption !!! excption: {}", e); + return ConvertorType.ILLEGAL; + } + } + + static boolean isPrimitive(Class clazz) { + for (Class c : ConvertorType.PRIMITIVE_TYPE) { + if (c.equals(clazz)) { + return true; + } + } + return false; + } + + public static boolean isArray(Class clazz) { + if (clazz.isArray()) { + for (Class c : ConvertorType.ARRAY_TYPE) { + if (c.equals(clazz)) { + return true; + } + } + } + return false; + } + + private static boolean isIllegal(Class clazz) { + return clazz.isInterface() || clazz.isEnum() || clazz.isAnnotation(); + } + + private boolean isInt() { + return clazz.equals(int.class) || clazz.equals(Integer.class); + } + + private boolean isLong() { + return clazz.equals(long.class) || clazz.equals(Long.class); + } + + private boolean isDouble() { + return clazz.equals(double.class) || clazz.equals(Double.class); + } + + private boolean isBoolean() { + return clazz.equals(boolean.class) || clazz.equals(Boolean.class); + } + + private boolean isDecimal() { + return clazz.equals(BigDecimal.class); + } + + private boolean isString() { + return clazz.equals(String.class); + } + + private int convToInt() throws ArthasException { + checkString(); + return Integer.valueOf(value()); + } + + private long convToLong() throws ArthasException { + checkString(); + return Long.valueOf(value()); + } + + private double convToDouble() throws ArthasException { + checkString(); + return Double.valueOf(value()); + } + + private boolean convToBoolean() throws ArthasException { + checkString(); + return Boolean.valueOf(value()); + } + + private BigDecimal convToDecimal() throws ArthasException { + checkString(); + return new BigDecimal(value()); + } + + private String value() { + return (String) value; + } + + private void checkString() throws ArthasException { + if (!value.getClass().equals(String.class)) { + throw new ArthasException(Constant.CONV_ERR_CODE, Constant.CONV_NOT_STRING, ArthasException.APP_ERR); + } + } + + @Override + public T convert() throws ArthasException { + return this.t; + } +} diff --git a/src/main/java/com/pangdly/arthas/serialize/convertor/Convertor.java b/src/main/java/com/pangdly/arthas/serialize/convertor/Convertor.java new file mode 100644 index 0000000..d8fe8dd --- /dev/null +++ b/src/main/java/com/pangdly/arthas/serialize/convertor/Convertor.java @@ -0,0 +1,13 @@ +package com.pangdly.arthas.serialize.convertor; + +import com.pangdly.exception.ArthasException; + +/** + * description: convertor interface + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public interface Convertor { + T convert() throws ArthasException; +} diff --git a/src/main/java/com/pangdly/arthas/serialize/convertor/ConvertorType.java b/src/main/java/com/pangdly/arthas/serialize/convertor/ConvertorType.java new file mode 100644 index 0000000..99ded0a --- /dev/null +++ b/src/main/java/com/pangdly/arthas/serialize/convertor/ConvertorType.java @@ -0,0 +1,83 @@ +package com.pangdly.arthas.serialize.convertor; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.HashMap; +import java.util.Map; + +/** + * description: parameter type object, type handle + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public class ConvertorType { + + private ConvertorType() { + } + + static final int PRIMITIVE = 1; + static final int ARRAY = 2; + static final int LOCAL = 3; + static final int ILLEGAL = 4; + + static final Class[] PRIMITIVE_TYPE = { + String.class, + boolean.class, + byte.class, + short.class, + int.class, + long.class, + float.class, + double.class, + char.class, + Boolean.class, + Byte.class, + Short.class, + Integer.class, + Long.class, + Float.class, + Double.class, + Character.class, + BigInteger.class, + BigDecimal.class + }; + + static final Class[] ARRAY_TYPE = { + String[].class, + boolean[].class, + byte[].class, + short[].class, + int[].class, + long[].class, + float[].class, + double[].class, + char[].class, + Boolean[].class, + Byte[].class, + Short[].class, + Integer[].class, + Long[].class, + Float[].class, + Double[].class, + Character[].class, + BigInteger[].class, + BigDecimal[].class + }; + + @SuppressWarnings("unused") + private static final Map, Object> PRIMITIVE_DEFAULTS = new HashMap, Object>() { + private static final long serialVersionUID = 5753182096254727686L; + + { + put(boolean.class, false); + put(byte.class, (byte) 0); + put(short.class, (short) 0); + put(char.class, (char) 0); + put(int.class, 0); + put(long.class, 0L); + put(float.class, 0.0f); + put(double.class, 0.0); + } + }; +} diff --git a/src/main/java/com/pangdly/arthas/serialize/convertor/ModelConvertor.java b/src/main/java/com/pangdly/arthas/serialize/convertor/ModelConvertor.java new file mode 100644 index 0000000..81af8e2 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/serialize/convertor/ModelConvertor.java @@ -0,0 +1,82 @@ +package com.pangdly.arthas.serialize.convertor; + +import com.pangdly.constant.Constant; +import com.pangdly.exception.ArthasException; +import com.pangdly.util.Assert; +import lombok.extern.log4j.Log4j2; + +import java.lang.reflect.Field; +import java.util.List; +import java.util.Map; + +/** + * description: model convertor + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@Log4j2 +@SuppressWarnings("rawtypes") +public class ModelConvertor implements Convertor { + + private Map> v; + private Class c; + + private T target; + + public ModelConvertor(Map> v, Class c) throws ArthasException { + Assert.notNull(v, "the convert source value can not be null !!!"); + Assert.notNull(c, "the convert target class type can not be null !!!"); + this.v = v; + this.c = c; + conv(); + } + + private void conv() throws ArthasException { + try { + target = c.newInstance(); + } catch (Exception e) { + throw new ArthasException(Constant.CONV_ERR_CODE, Constant.CONV_ERR_MODLE, ArthasException.SYS_ERR, e); + } + Field[] fields = target.getClass().getDeclaredFields(); + for (Field f : fields) { + String key = f.getName(); + f.setAccessible(true); + if (ConvertProcessor.isArray(f.getType())) { + List value = v.get(key); + if (null == value || value.size() <= 0) { + continue; + } + Convertor con = new ArrayConvertor<>(value, f.getType()); + try { + f.set(target, con.convert()); + } catch (IllegalAccessException e) { + throw new ArthasException(Constant.CONV_ERR_CODE, Constant.CONV_ERR_MODLE, ArthasException.SYS_ERR, e); + } + } else if (ConvertProcessor.isPrimitive(f.getType())) { + if (null == v.get(key) || v.get(key).size() <= 0) { + continue; + } + String value = v.get(key).get(0); + if (null == value) { + continue; + } + @SuppressWarnings("unchecked") + Convertor con = new PrimitiveConvertor(value, f.getType()); + try { + f.set(target, con.convert()); + } catch (IllegalAccessException e) { + throw new ArthasException(Constant.CONV_ERR_CODE, Constant.CONV_ERR_MODLE, ArthasException.SYS_ERR, e); + } + } else { + log.info("type is {}, the model serialize only support primitive and array type !!!", f.getType()); + } + } + } + + @Override + public T convert() throws ArthasException { + return target; + } + +} diff --git a/src/main/java/com/pangdly/arthas/serialize/convertor/PrimitiveConvertor.java b/src/main/java/com/pangdly/arthas/serialize/convertor/PrimitiveConvertor.java new file mode 100644 index 0000000..8b0a927 --- /dev/null +++ b/src/main/java/com/pangdly/arthas/serialize/convertor/PrimitiveConvertor.java @@ -0,0 +1,102 @@ +package com.pangdly.arthas.serialize.convertor; + +import java.math.BigDecimal; + +import com.pangdly.constant.Constant; +import com.pangdly.exception.ArthasException; +import com.pangdly.util.Assert; + +/** + * description: primitive convertor + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@SuppressWarnings("rawtypes") +public class PrimitiveConvertor implements Convertor { + + private final String v; + private final Class c; + + private T t; + + public PrimitiveConvertor(String v, Class c) throws ArthasException { + Assert.notNull(v, "the value can not be null !!!"); + Assert.notNull(c, "the target type can not be null !!!"); + this.v = v; + this.c = c; + conv(); + } + + @SuppressWarnings("unchecked") + private void conv() throws ArthasException { + if (isInt()) { + t = (T) convToInt(); + } else if (isLong()) { + t = (T) convToLong(); + } else if (isDouble()) { + t = (T) convToDouble(); + } else if (isBoolean()) { + t = (T) convToBoolean(); + } else if (isDecimal()) { + t = (T) convToDecimal(); + } else if (isString()) { + t = (T) v; + } else { + throw new ArthasException(Constant.CONV_ERR_CODE, Constant.CONV_NOT_PRIMITIVE, ArthasException.APP_ERR); + } + + } + + private boolean isInt() throws ArthasException { + return c.equals(int.class) || c.equals(Integer.class); + } + + private boolean isLong() throws ArthasException { + return c.equals(long.class) || c.equals(Long.class); + } + + private boolean isDouble() throws ArthasException { + return c.equals(double.class) || c.equals(Double.class); + } + + private boolean isBoolean() throws ArthasException { + return c.equals(boolean.class) || c.equals(Boolean.class); + } + + private boolean isDecimal() throws ArthasException { + return c.equals(BigDecimal.class); + } + + + private boolean isString() throws ArthasException { + return c.equals(String.class); + } + + private Object convToInt() throws ArthasException { + return Integer.valueOf(v); + } + + private Object convToLong() throws ArthasException { + return Long.valueOf(v); + } + + private Object convToDouble() throws ArthasException { + return Double.valueOf(v); + } + + private Object convToBoolean() throws ArthasException { + return Boolean.valueOf(v); + } + + private Object convToDecimal() throws ArthasException { + return new BigDecimal(v); + } + + @Override + public T convert() throws ArthasException { + return t; + } + + +} diff --git a/src/main/java/com/pangdly/constant/Constant.java b/src/main/java/com/pangdly/constant/Constant.java new file mode 100644 index 0000000..e9b96d9 --- /dev/null +++ b/src/main/java/com/pangdly/constant/Constant.java @@ -0,0 +1,51 @@ +package com.pangdly.constant; + +/** + * description: //TODO + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public class Constant { + + public final static String ARTHAS_SERVER = "server"; + public final static String SERVER_THREAD_COUNT = "count"; + public final static String SERVER_PROT = "port"; + public final static int DEFAULT_THREAD_COUNT = 1; + public final static int DEFAULT_PORT = 10880; + public final static String ACTION_ELEMENT = "action"; + public final static String BASE_PACKAGE_ATTRIBUTE = "base-package"; + + public final static String CONTENT_TYPE = "Content-Type"; + public final static String CONTENT_LENGTH = "Content-Length"; + + public final static String CONNECTION = "Connection"; + public final static String KEEP_ALIVE = "keep-alive"; + public final static String CONNECTION_CLOSE = "close"; + + public final static String ERR_CODE = "9999"; + public final static String ERR_MSG = "server is busy，try it later please !!!"; + + public final static String CODC_ERR_CODE = "9001"; + public final static String CODC_REQ_TYPE = "request type is illegal !!!"; + + public final static String DISP_ERR_CODE = "9002"; + public final static String DISP_PROX_MSG = "process get proxy failed !!!"; + public final static String DISP_WRAP_MSG = "process get wrapper failed !!!"; + + + public final static String PROC_ERR_CODE = "9003"; + public final static String PROC_NO_WRAP = "action is not exist !!!"; + public final static String PROC_ERR_INVOK = "invoke action failed !!!"; + + public final static String SERI_ERR_CODE = "9004"; + public final static String SERI_NESS_MSG = "parameter in uri is necessary，cannot be null !!!"; + + public final static String CONV_ERR_CODE = "9005"; + public final static String CONV_NOT_ARRAY = "the parameter is not type of Array !!!"; + public final static String CONV_NOT_PRIMITIVE = "the parameter is not type of primitive !!!"; + public final static String CONV_NOT_STRING = "the parameter is not type of String !!!"; + public final static String CONV_NOT_DATE = "date format is illegal !!!"; + public final static String CONV_ERR_MODLE = "convert to model failed !!!"; + +} diff --git a/src/main/java/com/pangdly/exception/ArthasException.java b/src/main/java/com/pangdly/exception/ArthasException.java new file mode 100644 index 0000000..45ed83f --- /dev/null +++ b/src/main/java/com/pangdly/exception/ArthasException.java @@ -0,0 +1,69 @@ +package com.pangdly.exception; + +import lombok.extern.log4j.Log4j2; + +/** + * description: //TODO + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@SuppressWarnings({"serial", "unused"}) +@Log4j2 +public class ArthasException extends Exception { + + public final static int SYS_ERR = 0; + public final static int APP_ERR = 1; + + private String code; + private String message; + private int level = APP_ERR; + private Throwable cause; + + private ArthasException() { + super(); + } + + public ArthasException(String code, String message, int level) { + super(message); + this.code = code; + this.message = message; + this.level = level; + } + + public ArthasException(String code, String message, int level, Throwable cause) { + super(message); + this.code = code; + this.message = message; + this.level = level; + this.cause = cause; + + } + + public void setCode(String code) { + this.code = code; + } + + public void setMessage(String message) { + this.message = message; + } + + public void setLevel(int level) { + this.level = level; + } + + public void setCause(Throwable cause) { + this.cause = cause; + } + + @Override + public String toString() { + return "ArthasException{" + + "code='" + code + '\'' + + ", message='" + message + '\'' + + ", level=" + (SYS_ERR == level ? "SYS" : "APP") + + ((SYS_ERR == level) ? (", cause=" + cause) : "") + + '}'; + } + +} diff --git a/src/main/java/com/pangdly/server/HttpServer.java b/src/main/java/com/pangdly/server/HttpServer.java new file mode 100644 index 0000000..ce38bfb --- /dev/null +++ b/src/main/java/com/pangdly/server/HttpServer.java @@ -0,0 +1,88 @@ +package com.pangdly.server; + +import com.pangdly.util.ArthasUtil; +import com.pangdly.util.SpringUtil; +import com.pangdly.arthas.dispatcher.ArthasChannelInitializer; +import com.pangdly.arthas.dispatcher.ArthasProcessHandler; +import io.netty.bootstrap.ServerBootstrap; +import io.netty.channel.Channel; +import io.netty.channel.ChannelOption; +import io.netty.channel.EventLoopGroup; +import io.netty.channel.nio.NioEventLoopGroup; +import io.netty.channel.socket.nio.NioServerSocketChannel; +import io.netty.handler.ssl.SslContext; +import io.netty.handler.ssl.SslContextBuilder; +import io.netty.handler.ssl.util.SelfSignedCertificate; +import lombok.extern.log4j.Log4j2; + +import org.springframework.context.ApplicationContext; + +import java.net.InetAddress; + +import javax.rmi.CORBA.Util; + +/** + * description: server initialize method + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +@Log4j2 +public class HttpServer { + + private static final boolean SSL = System.getProperty("ssl") != null; + + private final String name; + private final ApplicationContext context; + + public HttpServer(String name, ApplicationContext context) { + this.name = name; + this.context = context; + } + + public void run() throws Exception { + + if (null != context) { + SpringUtil util = new SpringUtil(); + util.setContext(context); + } + + final SslContext ssl; + final int[] server = ArthasUtil.parseServerParameter(name); + final int count = server[0]; + final int port = server[1]; + + if (SSL) { + SelfSignedCertificate ssc = new SelfSignedCertificate(); + ssl = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey()).build(); + } else { + ssl = null; + } + + // initialize arthas context + // + new ArthasProcessHandler().init(name); + + // initialize arthas netty service + // + EventLoopGroup bossGroup = new NioEventLoopGroup(count); + EventLoopGroup workerGroup = new NioEventLoopGroup(); + + try { + ServerBootstrap bootstrap = new ServerBootstrap(); + bootstrap.option(ChannelOption.SO_BACKLOG, 1024) + .childOption(ChannelOption.SO_KEEPALIVE, true) + .childOption(ChannelOption.TCP_NODELAY, true); + bootstrap.group(bossGroup, workerGroup) + .channel(NioServerSocketChannel.class) + .childHandler(new ArthasChannelInitializer(ssl)); + + Channel ch = bootstrap.bind(port).sync().channel(); + log.info("HTTP Server: {}://{}:{}\n\n", SSL ? "https" : "http", InetAddress.getLocalHost().getHostAddress(), port); + ch.closeFuture().sync(); + } finally { + bossGroup.shutdownGracefully(); + workerGroup.shutdownGracefully(); + } + } +} diff --git a/src/main/java/com/pangdly/util/ArthasUtil.java b/src/main/java/com/pangdly/util/ArthasUtil.java new file mode 100644 index 0000000..dfd51d6 --- /dev/null +++ b/src/main/java/com/pangdly/util/ArthasUtil.java @@ -0,0 +1,221 @@ +package com.pangdly.util; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; +import java.net.URLDecoder; +import java.text.DateFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Date; +import java.util.Enumeration; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.jar.JarEntry; +import java.util.jar.JarFile; + +import org.dom4j.Document; +import org.dom4j.DocumentException; +import org.dom4j.Element; +import org.dom4j.io.SAXReader; + +import com.pangdly.annotation.Action; +import com.pangdly.constant.Constant; +import com.pangdly.exception.ArthasException; + +import lombok.extern.log4j.Log4j2; + +@SuppressWarnings({"resource", "rawtypes", "unchecked"}) +@Log4j2 +public class ArthasUtil { + public static Date strToDate(String source, String format) { + + DateFormat df = new SimpleDateFormat(format); + try { + return df.parse(source); + } catch (ParseException e) { + log.error("convert string to date is failed, exception is [ {} ]", e.getMessage()); + return null; + } + } + + + public static void findFilesInPackage(String packageName, List classes) { + + String packageDirName = packageDir(packageName); + if (null == packageDirName) { + // TODO + return; + } + + if (packageDirName.contains("jar!")) { + String[] names = packageDirName.trim().substring(5).split("!"); + try { + JarFile jar = new JarFile(names[0].trim()); + Enumeration entries = jar.entries(); + while (entries.hasMoreElements()) { + JarEntry entry = entries.nextElement(); + String fileName = entry.getName().replace("/", ".").trim(); + if (fileName.contains(packageName) && fileName.contains(".class")) { + try { + Class c = Class.forName(fileName.substring(0, fileName.length() - 6)); + if (null != c.getAnnotation(Action.class)) { + classes.add(fileName.substring(0, fileName.length() - 6)); + } + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + } + } + } catch (IOException e) { + e.printStackTrace(); + } + } else { + File dir = new File(packageDirName); + if (!dir.exists() || !dir.isDirectory()) { + return; + } + + File[] files = dir.listFiles((File file) -> { + if (file.isDirectory()) + return true; + if (file.isFile()) { + String fileName = file.getName(); + if (fileName.endsWith(".class")) { + try { + Class c = Class.forName(packageName + "." + fileName.substring(0, fileName.length() - 6)); + if (null != c.getAnnotation(Action.class)) { + return true; + } + } catch (ClassNotFoundException e) { + e.printStackTrace(); + } + } + } + return false; + }); + + if (null == files) { + return; + } + + for (File file : files) { + if (file.isDirectory()) { + findFilesInPackage(packageName + "." + file.getName(), classes); + } + if (file.isFile()) { + classes.add(packageName + "." + file.getName().substring(0, file.getName().length() - 6)); + } + } + } + } + + private static String packageDir(String packageName) { + + if (null == packageName) { + // TODO + return null; + } + + URL url = Thread.currentThread().getContextClassLoader().getResource(packageName.replace(".", "/")); + log.debug("the url is {}", url); + if (url == null || url.getFile() == null) { + // TODO + return null; + } + try { + String path; + if (System.getProperty("os.name").toLowerCase().contains("window")) { + path = url.getPath().substring(1, url.getPath().length()); + } else { + path = url.getPath(); + } + return URLDecoder.decode(path, "UTF-8"); + } catch (Exception e) { + e.printStackTrace(); + return null; + } + } + + public static InputStream parse(String name) { + + InputStream stream = Thread.currentThread().getContextClassLoader().getResourceAsStream(name); + return stream; + } + + public static int[] parseServerParameter(String name) { + + try { + Document document = new SAXReader().read(parse(name)); + Element element = document.getRootElement().element(Constant.ARTHAS_SERVER); + String count = element.attributeValue(Constant.SERVER_THREAD_COUNT); + String port = element.attributeValue(Constant.SERVER_PROT); + return new int[]{null == count ? Constant.DEFAULT_THREAD_COUNT : Integer.valueOf(count), null == port ? Constant.DEFAULT_PORT : Integer.valueOf(port)}; + } catch (Exception e) { + return new int[]{Constant.DEFAULT_THREAD_COUNT, Constant.DEFAULT_PORT,}; + } + } + + public static List parsePackage(String name) { + + List namespaces = new ArrayList<>(); + + Document document; + try { + document = new SAXReader().read(parse(name)); + if (null == document) { + return namespaces; + } + Element root = document.getRootElement(); + Iterator it = root.elementIterator(); + while (it.hasNext()) { + Element element = it.next(); + if (element.getName().equals(Constant.ACTION_ELEMENT)) { + namespaces.add(element.attributeValue(Constant.BASE_PACKAGE_ATTRIBUTE)); + } + } + return namespaces; + } catch (DocumentException e) { + e.printStackTrace(); + // TODO: to add error handle + return namespaces; + } + } + + public static Map paramsInUri(String uri) throws ArthasException { + if (null == uri || uri.length() <= 0) { + return null; + } + String params = uriSplit(uri); + if (null == params) { + return null; + } + return paramSplit(params); + } + + private static String uriSplit(String uri) throws ArthasException { + String[] arr = uri.split("\\?"); + if (arr.length != 2) { + // TODO: discribe exception + throw new ArthasException("123", "123", ArthasException.APP_ERR); + } + return arr[1]; + } + + private static Map paramSplit(String params) { + Map map = new HashMap(); + String[] arr = params.split("&"); + Arrays.stream(arr).forEach((String param) -> { + String[] pa = param.split("="); + if (pa.length == 2) { + map.put(pa[0], pa[1]); + } + }); + return map; + } +} diff --git a/src/main/java/com/pangdly/util/Assert.java b/src/main/java/com/pangdly/util/Assert.java new file mode 100644 index 0000000..d2302f8 --- /dev/null +++ b/src/main/java/com/pangdly/util/Assert.java @@ -0,0 +1,17 @@ +package com.pangdly.util; + +/** + * description: //TODO + * + * @author: Xue Bin + * @version: 1.0.0-SNAPSHOT + */ +public abstract class Assert { + + public static void notNull(Object object, String message) { + if (null == object) { + throw new IllegalArgumentException(message); + } + } + +} diff --git a/src/main/java/com/pangdly/util/SpringUtil.java b/src/main/java/com/pangdly/util/SpringUtil.java new file mode 100644 index 0000000..69beb05 --- /dev/null +++ b/src/main/java/com/pangdly/util/SpringUtil.java @@ -0,0 +1,28 @@ +package com.pangdly.util; + +import org.springframework.beans.BeansException; +import org.springframework.context.ApplicationContext; +import org.springframework.context.ApplicationContextAware; + +public class SpringUtil implements ApplicationContextAware { + + private static ApplicationContext context; + + public static ApplicationContext getContext() { + return context; + } + + //@Override + public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { + context = applicationContext; + } + + public static T getBean(Class clazz) { + return context.getBean(clazz); + } + + public void setContext(ApplicationContext applicationContext) { + context = applicationContext; + } + +} \ No newline at end of file diff --git a/src/main/resources/log4j2.xml b/src/main/resources/log4j2.xml new file mode 100644 index 0000000..a78022a --- /dev/null +++ b/src/main/resources/log4j2.xml @@ -0,0 +1,53 @@ + + + + + http.netty.log + /mnt/default_logs + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/test/java/com/pangdly/Http/Netty/AppTest.java b/src/test/java/com/pangdly/Http/Netty/AppTest.java new file mode 100644 index 0000000..6ae91bb --- /dev/null +++ b/src/test/java/com/pangdly/Http/Netty/AppTest.java @@ -0,0 +1,38 @@ +package com.pangdly.Http.Netty; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +/** + * Unit test for simple App. + */ +public class AppTest + extends TestCase +{ + /** + * Create the test case + * + * @param testName name of the test case + */ + public AppTest( String testName ) + { + super( testName ); + } + + /** + * @return the suite of tests being tested + */ + public static Test suite() + { + return new TestSuite( AppTest.class ); + } + + /** + * Rigourous Test :-) + */ + public void testApp() + { + assertTrue( true ); + } +} diff --git a/target/Http.Netty-0.0.1-SNAPSHOT.jar b/target/Http.Netty-0.0.1-SNAPSHOT.jar new file mode 100644 index 0000000000000000000000000000000000000000..d20b4e9ca26e474ef77ac7d4f55c3efeab21f674 GIT binary patch literal 62901 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

78{JDhhlG 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 literal 0 HcmV?d00001 diff --git a/target/classes/META-INF/MANIFEST.MF b/target/classes/META-INF/MANIFEST.MF new file mode 100644 index 0000000..3903107 --- /dev/null +++ b/target/classes/META-INF/MANIFEST.MF @@ -0,0 +1,5 @@ +Manifest-Version: 1.0 +Built-By: Administrator +Build-Jdk: 1.8.0_112 +Created-By: Maven Integration for Eclipse + diff --git a/target/classes/META-INF/maven/com.pangdly/Http.Netty/pom.properties b/target/classes/META-INF/maven/com.pangdly/Http.Netty/pom.properties new file mode 100644 index 0000000..67fdac6 --- /dev/null +++ b/target/classes/META-INF/maven/com.pangdly/Http.Netty/pom.properties @@ -0,0 +1,7 @@ +#Generated by Maven Integration for Eclipse +#Tue Dec 26 20:54:25 CST 2017 +version=0.0.1-SNAPSHOT +groupId=com.pangdly +m2e.projectName=Http.Netty +m2e.projectLocation=F\:\\workspace-for big data\\Http.Netty +artifactId=Http.Netty diff --git a/target/classes/META-INF/maven/com.pangdly/Http.Netty/pom.xml b/target/classes/META-INF/maven/com.pangdly/Http.Netty/pom.xml new file mode 100644 index 0000000..d74ffaf --- /dev/null +++ b/target/classes/META-INF/maven/com.pangdly/Http.Netty/pom.xml @@ -0,0 +1,132 @@ + + 4.0.0 + + com.pangdly + Http.Netty + 0.0.1-SNAPSHOT + jar + + Http.Netty + http://maven.apache.org + + + UTF-8 + + 3.7.0 + 2.20.1 + 3.0.2 + 3.0.0 + 2.8.2 + 1.8 + UTF-8 + UTF-8 + + + + + junit + junit + 3.8.1 + test + + + + org.projectlombok + lombok + 1.16.16 + + + + commons-codec + commons-codec + 1.10 + + + + org.apache.httpcomponents + httpcore + 4.4.6 + + + + io.netty + netty-all + 4.1.15.Final + + + + org.springframework + spring-context + 4.3.3.RELEASE + + + + dom4j + dom4j + 1.6.1 + + + com.alibaba + fastjson + 1.2.38 + + + + org.apache.logging.log4j + log4j-api + 2.7 + + + org.apache.logging.log4j + log4j-core + 2.7 + + + org.apache.logging.log4j + log4j-web + 2.7 + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + ${maven.compiler.plugin.version} + + ${java.version} + ${java.version} + ${file.encoding} + + + + org.apache.maven.plugins + maven-surefire-plugin + ${maven.surefire.plugin.version} + + true + + + + org.apache.maven.plugins + maven-deploy-plugin + ${maven.deploy.plugin.version} + + + + + + + nexus-releases + Nexus Releases Repository + http://192.168.0.99:8081/repository/maven-releases/ + + + nexus-snapshots + Nexus Snapshots Repository + http://192.168.0.99:8081/repository/maven-snapshots/ + + + diff --git a/target/classes/com/pangdly/annotation/Action.class b/target/classes/com/pangdly/annotation/Action.class new file mode 100644 index 0000000000000000000000000000000000000000..c85d4bc6fe0d7a8b8fa77f0df6ef6f461f603294 GIT binary patch literal 498 zcmaixJx>Bb5Qg93!xQiW6blQ2S`clx#?FcaOiUCBoF>LXiCe}F&A zI2RM3AhFoYzB|vnGuiq6`TPQKi!%>7LL-bLf3ECwVphJgHg?MC*!rC?3myuD>P#(_ zZ-num$1@I{hdn}b^SWKOb|4g&%A`!FU*9}#;E`KsJG~>+I%~GeA1XDDPzsGolD>+h ztUQX-MacKsh^YL{)6RSd=fl)G9r3G9^w{vmC?Q;K_1YS&8;5Dc*6~DIH+D0DT1?qV z{%Uu=XE?J6R&y4p5WEd~gp1wmke#6Ng+jLeK?bqW;YvVn_|gv^o_Z|;Aup#Wn<80( nhka2cQTYUAMZHnrRzxcuM{*8 zjl|FXDC4^oT2~3I5l*K0`)DoRcDC5uI%kH%#{BRP-IA)8cxe%$d+$#DuHji zHM;EE+CA8rscw`Hwkiy>Z+nAGl}yKW?O=^T$``7{Xwy5kQb?qbVaOPbhGUzZW=@)( ztAMJjxQihMxfCYm^WA*5yIqB9nzDygBp~yzdn(dU7zWC=Ywfn`N0z^D966#t&orE> z;oIC6P6ZMsc;QKcxUF6X{l1DMQq)E8-fl9aYF1F~Xf~8DbW@^;=5<8w7Fe!`EL117 zxqP7~RTbo+B~c*#B6Dgt1FNoL9t#XXQgGRO z$M7PW7A`@dmzi@VpQu>GGQ&y~WYaO4&0@DmQQi2~(yl2LujQN8OPfzC6WQ`5-Z1r7 zv1_gow0yc=jUe*$QZFReitEd?A`<<^r1eq0G4vJVvjs9^d~e8>$?Ahjad*htpeX)K zeg!+s_Dk7;3k;qk7ym}KbcS5z93vkoAcj$TD|CX=2MBCTc=-)2b_n;1ipR;XYV#8p z7}pj*W9lZmUr@^sg+ao|3WQ;SsN#VjOPPYMM0gJ|9ir-VGD1ygpD^`7l;vb(;mipb z-VX(YFbt0{LmuAY8WrHAWo`ZsGM!eqN@Ecs@--1z5TU7H7LP-$Rf^{74xeG<@QtKh z9hSIGJJR?i<`({D#sn^}ouk+4)*W77@ksO4A1C4lbt%e-2iZJ{j$5Cm9&H(gZfs#1bz)ew}JZn_$rOE8+u7<-JAzs7h+`QPVn=Ld(Lk=IFcUc#iMGiLjWHb-q-Yb_DVX zl|H*G+a=Uw?un0U^G(L73kETZ)6Vm-(pjq$5T+7NV{1|-?ENd@7c`34eLCVVuJpCj zI+Z)H32j#r%ICrH;YY$u$7V^$$B`CsZq)73uoc2uJ2Nio^YDZQlxn-UU@HzsJGgKoE@py4`+`IwH)n=cb-bcfXpP4 zgh6k$$2xUNN_iBeu_t=Iq_E1mwfiiSq2Z*V@&obeC;mi=Jd{FiHs0Onu^V}5AVMXk z)W+p@#^v!$D7r5$xlHNd+wGhsMHc0*79xXteQVHVDA^sSGqhaGp&4&CIzo|;hE2BS zKZqSk-&+xAI4@6be`qxs%|)kGqzP&CMFw`MDp92;D3h><{Xb!h18AsZBo0xf^NzeV XI*$lBeuE}Z$4R!G;w+N{&e8Y*Mq literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/annotation/RequestType.class b/target/classes/com/pangdly/annotation/RequestType.class new file mode 100644 index 0000000000000000000000000000000000000000..0374213d43c96bfc3634a375f545a66aad723e76 GIT binary patch literal 1376 zcma)6ZBNrs6n^fybuUylDhzoM5mC1CGC@I-Ed)cR5(gLyOQxU7sI#PNaqCF-uM{*8 zjl|FXDC4=83YB5pKCC_GKIb{leeSva`RnT$fX7&lBE&FJb?dnU!>R4r?VRB_u4j0b z>*QXWA6jP9+ioA2QG^+K_l-j%XA>}2bXs)=>3MORVY2l9`aDDU)s{}^$f04kOa`@d z$)|Gt$&%%mo2~k;+1NIAZLux4YS?9? zVewcb6Ob^*Ror1nU)TJ+)m;TK#7VsO-fA+$YNl5{x2ivr?bJtz<^^Kl8d`3IEX*dh zsZ6#jGZWA-6U8(`DsVjQrf1d_%wmoqZZsN3yXqda8MI*At=)aI>g9u0{zm9>#u*^UEY&S>Eom^0m!y|^pAjz6-G@JQOlY+kSk);t!=x(b~HJ@4hv{Hc)pW_>* z{pnWCF}zlTmX`vIyu8qj$d&x+JdKD%7c9Iw#K#AqCru7zLi~(@)G(hPie-uw+#q}} zMQ;ere+%EhDr!c<%RL{%Y-(0{M!+=C?X zj!~~svBFpB8u)!)5GG7{MVlTy!EJ5!3&yW9q)1yIX;cM6n(7IU39$?Q#`hr+-#twF ztT}ozLPfOC82>2RazV044hS0M9N^Q?4aWn@@U5><1KvW`rvDO?5Ls^Ha6pKBA%q*q zZ)6-($oO1Kgy#0Ak1$kuDQRbw0(Wdf8aYLF=BhGwVNskW>!Ht~QD459gvzv2%>MxU QcU_3Sq}<>|EQ#ln-$@@LegFUf literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/annotation/ResponseType.class b/target/classes/com/pangdly/annotation/ResponseType.class new file mode 100644 index 0000000000000000000000000000000000000000..c916c3428d561d50999dee3611523bad2c8dea36 GIT binary patch literal 1316 zcma)5YflqV5Iwis$F{6I7OcE|@UUGTD+nUCArMj{T4>Tjlg7m4Qr5a;yW6x|V*izb z2BMMp*&k(`yREXZnzSG8-I+Uc=A4=7kDp(z0j%L!1ObMbvQyP-+^(EhEuGu8<8s$@ zY&~x@YL4A74qG)Nf*?cxDL>=7MUi^OZdMtBFAKQ?hPiAH2q}h8CZEsc=|1CD(_m1u zH-H7VZrT+J>dPD)?avl>vPYQ$!~E+WvE_8xGHuh{VvrKaB5~VwP7E0#8AA+%yjHW! za$DDF!?9yv7*;TX+YI4!Coz%eCbZY>N*1G(eMdnEVHpt_;|wv^c<<^pi<`E1oKz4& zSbR+@h@p>RAZyyjL9=>n)DQWw<*9ed+$!?ADQwRfgM)=M>0@l0^5N z*hFffRbR?1N=1U5_hEr%Fk?gIZF)U&^f+cF5Z$_<#Yg85Jc*GFp^*V2romz`Q z^K;D|pBiO1nuRBr+JG;ttnW+I>WjjW!K`3Myk69{XSwSl7IY&Jhr5(_Li6RM& zJVO2xk}uj8KgU$*m84yl(n9IJG;xK6#lO+mA6Ze_iPa8 literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/codec/ArthasHttpRequest.class b/target/classes/com/pangdly/arthas/codec/ArthasHttpRequest.class new file mode 100644 index 0000000000000000000000000000000000000000..1f19b549d22514d1e97458a90c143e0c36174297 GIT binary patch literal 4013 zcmbVP>u(fQ6#q?kW_P*_P!=dIq9Rmix2@{~1b1nnlvlA}rC0=?)9u&}YshxNF1SIqP@eM&*)g>^6^4~_-qo5HgbA1idM>-y+-#8w z+2?03dj)di2DT`!U(QZ@Ro^Z8@3^x?kHUdk&Un?pFPC1NIA*{&ZD9R)xfFzMDV%YO zHP7n$`j5{(9{=+n17>)=Lbblhrl3lta_ELMkc|R4PpQ0t*t{1S*f^yo$ z@1FMOOKw=J($xOu-9vh*!k-SSerZ16&Kac*vr-Od{A7pf%KM}rgljk$&5J=REMM_T z22$<*3?!I|BxPVv|3GKSo8v4}HwW;sz)-W7d)A%N#~I*BL3zL+7jTYYO`V%KbDVKc@H|w#pjM=RD+f1ovxaD zwB{G*ysC{ixY;(5`z800Bwod=g97%`?;*eBhoi#s9K4BnvfN6=E6o`gZmeg$Ty2dR zdCc4JsXMfjVJi<;#9Xn(N;E^Gnb2@hR;_U6C5CoN)+075JQ71YRq9-^gvNk`8ajAI zDo#Xa1ktx7o0@?O9ra&J!>ze&2rVyXcv1`Vc$9q^<74q>I})%-ck_>jE+qNz+EFwIIQcz_-b6kJ?#g;I*Bq+c+dv-MpYI2_ z%JOUQYh`{w`dg*?Am4GtOkoFUM+@K~Jj|6LbAraSn@8J>?CQ)2N6dC6bH z6XR)3Bh#7k5QZb=93$zHq%(s{NPkDF3#}mZYKaI00Z336>>ekEbvT|-!Ax?!VsDq& zi*;a6SMNzmYrx~I)F$QOsRj>Ew|m&rsRw-?8a<@2S$Wup{rn1$O;}{aawk~G$r3Dh znP@x4d(>M;?e7OOU%@hO4gLz_3s|vRgTKHyGn84zLA4~2KRd)%&K&*?>(b^OY`O_& zIBhOtq%LtdXHn#EE}phTCVmI0n^>Q=((wkNv0Q>eV>vsW5FtAfN~G-uq48Wdg~oHq zbhij4BcbkevMyxaV$|*Rs_1N1>i<2C;{@=vgvKV^rXCDo13c~YJymBbX|cm^92_FveLfblna6NvHG zCi#FSyYE8MGjDxe2|UZMoJLDZAj#dWpw>!q76X^$47pFW8RH}BC8%BL$saODRM~d) z6v@gimzsYSpqkdndpCSGC|G3+MD7fG2I#Z$OM%Hnz(UM3Y+Fn zY#4-=pMUvYU3Up%E3CReUB+x?MPl&=u~o@dZX}#&7G9NKV}mNpkvFui3FakK)@0-- zym~S9`fa#Umu1YQ7M5{YY9aKZrpJUXYkHiY)K$Kg5!`E9jzj<(@@GKgboIu#jccs~ zV)L3eMgea#(jIm8uHzkk<@$M-&wDS!4B!OV5Fi!shLRa{gXOdM-JYQbHIp+#OW2he zUc#PC+FXK~ON~9cMY-LlwN{St_Gm`alKgW+t3t^Xj44W{mI;}Mdb*30+?!fzvjX>h IuDbBSf2d$L{r~^~ literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/codec/ArthasHttpRequestDecode.class b/target/classes/com/pangdly/arthas/codec/ArthasHttpRequestDecode.class new file mode 100644 index 0000000000000000000000000000000000000000..432e8d5648c177c7e34cfadcaedca33a5d577967 GIT binary patch literal 285 zcma)%yAFXt5QWdUty|#%v=SPt(5WPdLL%V_)|$BFXMg`L;nfr#z(a{4h(@BA%$%G# zlW(rK^94W~WrY->W!*-{X1kb2CvB3jG+tXbXREtUF$^J|@NUmO^!Q;YWC)eDIT#&D zOpj-4wt=AH#98*9(5yE`|6lD8iv6SIIIP^(D-;N|?=-)?7tm){a#OcYEDu%@6RJOW cn-A0+fsmHB0TTQya-x-}jP$%zQRWm%cka7WF#rGn literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/codec/ArthasHttpRequestDecodeHandler.class b/target/classes/com/pangdly/arthas/codec/ArthasHttpRequestDecodeHandler.class new file mode 100644 index 0000000000000000000000000000000000000000..aefee5af79697b86fbcf8a95f089ff83eb2f7e10 GIT binary patch literal 5371 zcmb7HX;@U(8Gi4~;2nlbfFV)QMnO?w0EZZj3W`w>p#e04STs#?87|DoFf+Mx$A+d$ zx|r^JYirXc>6)%7u?dK_#%`uf(>C4rbl=zCee&e#d(OSi+<}4Mqrg4eci!*)-tRl- zJoWtfivYIbzbZTmwnvf^;gp^j8;MVbb<>LK>2M@DVno7wWuwcoQiqMZGDh0!FvLKY zo*0Q6rV5{e@)P<=Jsjui@WJ5|M#NIFOhNP2npCiC!my&r5e2Jyawbh`nrXu)ekE0wG(InUX*Gm#x)AOb@hYAAYctD{0ho?VhN)!GcjzK1Nv~> zP!Q}%M)dfgZpK90>GWCASX#l(o~!l9A&HpPl$neeXs7o+!8-SRJ&{OSx-b@Y!Z|RRGBm8gTGDf1|A2zpe0T*H zv7P;m2N(O89W z;ccUaCgFwe(82xzF(Is>88@&al}uX-4%aOO#8n2TwBOPr*Rs+Gm5Xvrla;qO*3W}`cxRD6p#pqFS%MyHaR*TU0 zD%iL%Qdx~0@G1@}2o;FP0u?TRKHMrw#$g3Vm!ujyWLb6!HrjFnRA3GN+<>So%o z!tM574P%JX^k~xT(MFlV?dK7`5HRF)TTXBv_ z9$m(YMa^?Ym*<~pEY{Aswk?0zuKB8(-_ypO4=iz=#M2W?TLmn)wYJG3@+xr@znbak zmd*kN&ba{u@EW{M#cP@W+1M_+Lc{AtG4v&BZZsDHL!=N6|7=FB00RlLU4JzKBcRjPE>&F?gv9r1P20!j+);cw) zTAbt6v2=AT9yiAHcy&!pO#mzLVIlGd6x6w$a*|-aK)S`v%M+z4JtO>8+#efD=vKyL z4tEzYFy~+?pp^Mrw9)U=__&5o;FG*6#Erz5#bUwRUAH**Kc(T*;&kxy@as>-W0vUr ztcK5tqs~r4+0CW)xu@a_3QF@*$d52zbR~u|q4t`lKFO-`ReX&eq%G4B zC17)%dzUL0C0C-_6T^%f=eKJ31}<~C9uarTTbtdNd(LQgSvaeZQVM6Ye;ebl{1 z+&$(qT|el@4@lVV5Z5wZ zN}7`zev9AnYBrJUQt-6f8)v0$+HCfDB%RsT!2@n6V_J(Glg&H15 z*`sWEP{H5Va4oPFK2&o>4J`o6?b)crwQPx+Ev!<=xK56(V4shzmD2i<+#OhR7OO&` z$51wd>S@%TfuGyeO@+>)VFsJ0xW?<+aU;Js(OSLSQKL0laCY1x=PCjQpHlptzv2B@ zCPD8xhZ`^P`5S7O1@mGCdoE)mzuU>ffoXL2UO?ZF0F@nA8fS25N_5YlKZj^JxdX!V zvY8%lArm+9{j*IXtG2gtkg3>#0UROPYJ%#*Ai)W=Wal|-SNZzzh{xSL$j=b+GS2Ig zkdO8@&SJLZz2_GawB7QdZ zR$|{xjBSkM9<*Su#NKA_nT=x?AI58mUFG-yP7-A$y%b(}*inu3$?g~ zQR_hmdU2S~m_ZzpENrzAWm!1J6++D_`eiId9(3bD$wDn|!bAM>$*7jY`@D>*iqrhB zRnT8POvzSGkRPG99(+`0!oB?Qu2k z?%=9y2u@AoY;WVmq6bl=Of~wp%tdlLX}JTXxD#afHD>5 z*ye?Xzum;#$F}gZ`T}N|dKY>df?pz#zNT}y*mxdKf|rYLdeAr*%@_j}C6X9RLsFs% z*>EIUjmNX|IPiDMNK5{@WNG=ZPW;HZT4vn(a7$*Z{h=bYfdFYrtL a6=;6XzCYqG_#6Jt9#NwIfq&sYsQN!@%#Kq4 literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/codec/ArthasHttpResponseEncode.class b/target/classes/com/pangdly/arthas/codec/ArthasHttpResponseEncode.class new file mode 100644 index 0000000000000000000000000000000000000000..0f029fe56606c39e0ae9b85cf7fe4ea287dc3ca3 GIT binary patch literal 223 zcmZ{fJqiLb5QX3Pw`%1D?6q+e?5r$YECfMM5VM1;#AMlI1+Qk|0X&qL6$=}i#|)48 z-n{4Q{s1sXFF}Ja)9%8Bvd7HaSd}4Hp0&$F^YXK-LnwCQ3unEoZ0#gy5e8>pJ3jYK$JQIL^Ltg1ie^nmw}tQT z>2+UjKwgDt(-&)&)y!WijCY75Pq@3n9TBeUxFe&ZqkVW6mla%M7;gdBKBk8EFwD@i zu(p<4W4L*)JXKu9`wFfx+-nK(2KTMu16*eabHfmxH!)4wMxt5AE$h6>jf&7Mr(7oD zZB)XASk%X>bis8z!1h#6W zl5q8>cGYn#QPePv+YAFgxV%~w#q`lG!}Z8Ux=A;|A?ceeh_Jg158s|Jaz}hA_=w@| zabj(>`AC#_&GJu6v=5))Qw8^ky0cD8RTqToQ9)?952~ebCZB(@d3%!pH-T#txanxB z51-+41=Jj-Iz?+pWSz>e=4p6{Ifky>GQ;$lHP~E#^|L9Jn%}(aK93k`k&dSWoT-k6 zttmFypSt2`p&yILDENXQaTe~=m!n|`j~SGT;6);zAx;%|mIDbsQ#U4IWf`=2$M%Ko zCuR3isqd_6$l*y{-UV*esQq3drza&6bVC(u$SYVshc1GE8lHmseK#)_8FJ^V!#4o) zoZ&(POjg)szoOzRe63)EVfdJnR^~N)gKw!IU7|!jEkQlg!?YwDz;_xrwus+dNkp#1 za5=KnhKn!=(Zbu8s2e<|RHxKTWQUV)-hU{kJ)drgC?pgNS5L@kMJ0=`;gSmJ#H>y6 zomLc`9iXZ(Uas(J@X)I3PR%vMqA8!^iB2eG)+DPX+ZOJ;#XV0p$iYS>Wa@tvFaknB ze>#9J`p~mabA@I)jf}>g*eis8Ioej~TW$m6=%;V3Zb0Jz&BC~VL0XZA|0YKv8b$06 zDDgj`4qaT{Cn67VW$44$Ym9Uwc7R)lNUX@EJBg#E-!SuHA0O{yHt`DS)#Pg|5c|vV z1FRh2%b{n91H3rICjEXUPZ?xDj*>r9pl-!rOxR+LU=yw-v NI5etcPf9=)>c3y!;XVKW literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/codec/ArthasHttpResponseEncodeHandler.class b/target/classes/com/pangdly/arthas/codec/ArthasHttpResponseEncodeHandler.class new file mode 100644 index 0000000000000000000000000000000000000000..6ce39d41b0d3857805e408c64980d155374a42ed GIT binary patch literal 3423 zcmbVOTXz#x6#h;!lS#sqmOu*ugaSp2X(x#;gie1gjx$M2qxA*?`KJ&-FKmP(?0N-ec z2plds^SP>F&(2h?Z9AUfS&p4+cyf+n6ps&;Dwb_|$9R6GyGZ?$bTEkx z*r*{Tu;)=|#thpaA|0F1E|8cty#S)XK&A=X$%;{{4R$})u>=G*>(CGvXf0T_IbNTi zHr;c^bcG(J3QozW6b;vs^KenCx=zWg)dc!8-380Z*{0`R%awx!g=s7^fw|N5N~JlI zgYvYebR>|Jqn$d|K~G{A_Gs8GFtRLsPe6*UMu0<-=;*>;fmi@ZV756jVb<1^t0#0% zGNEiSF!|-ypTHH#rg_7%1v)YpoAMc=?k>jBBcR$=*>Do*Lr%kfGG=|$<5>(aN<$$R^Zz?a#Uzm&((xP)lij3b(Wul(pH1Y)L*=p#c?@ZwqdOnP zbD!f!!5UF4`?4d@z6!i|*1LzL;3R$J8ODA3Mi)}$;k#>}_tMujMsIoxpKf^_(-j+ZgcP?rpQ zSW3&qDIG83a1v3xqGJqxj$hR=f>8m%_%(N~&>D&4cxBUNACbK63R+y!UkfL}M$q5F zjbPF;6hsnp&04+UaWOnV?F#J0 zJtyF}hAV7ID`|70ZdGPXH;#Gs*~i=w8R^H-B84EsCJ46|&sAqq|cK&wU zLFe}?G&_AwJ&?oG*vI_@GX9bB=rR;q0W$X>&Zn|B(R&*Q3OCWg(E<+M#gPa&>si3_ zcX2#|C1fdT0!QdZo`?o%dB{JjBd~{480LNp_fB(<$(KdSr#v<1&jD2;UkSOR39=eO z<`s$2Rg`zEP5BIth01xNlm5oCJ-4uZ$(ta~!O?*SvG8b_1DQPO!AmHtW@pD*?a1Uy zJ8V*+oxg}iBc5_k_B*J`jh^2izJ(gS(eo?BSZ{U#6aJKg$#G_6GOzUgj&*6}J~mv3 z-j`MuaIPUy%&QbB=3{A9%Eay?bsa5fH63dRDK~glw24`P$0GrTMUTsP4d;ol9aFf# z>_zxlaS9i?7Dbk^e4QhO`P_v!I8y1)HoVDE3~$kXClXrxZ>-lK{y~R^DF5ReZV847 zUTm_9hY>i!x6FttU6=5hiQk-%1{WwwP!gVyT{blHC-qcn=i3H{l%syQwzmzI8LW6) z&vj^h3z)tn*Nb^YZlslPCoV(Ct?jFaW+1Q{h9=6Jeg-DbRB;fOIf{@P{g@@5DE448 z3rdDYhT#m92V77X1|jG=Uk~_Pnn&b9JJg0iLq=J?L@}PnmKl0FAx+W#-g}rkpQ_x3 zExlbpHRbUkJzT)m)HRM5@cyIfWA9>d@pFidd`P1kX!;}mKE8-Z4T&1RQ)R)9aXZR) zYxXui@k=M$dkYWoezRY?oq^~gn_9#Ap}PF+MWii`&+vKZPM7Ztps>xXM7z}YBKU&G RNAM-S;#*eZF8;no@;}P_>>B_8 literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/dispatcher/ArthasChannelInitializer.class b/target/classes/com/pangdly/arthas/dispatcher/ArthasChannelInitializer.class new file mode 100644 index 0000000000000000000000000000000000000000..450e0f995d4223e1caebc604ff825315af41cdcd GIT binary patch literal 1872 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 TcDxI3;}3LP;E!~v3Ge(5ln+?< literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/dispatcher/ArthasProcess.class b/target/classes/com/pangdly/arthas/dispatcher/ArthasProcess.class new file mode 100644 index 0000000000000000000000000000000000000000..be02f7974e718dbb8c488e7f47b1cdf01690a20b GIT binary patch literal 272 zcmY+9%}zo=424e-8AKMwcQApFSQhM9v4F5J!RQkVa~tj@AKw5>&^KriMlQT?wDqR&2ewTvZQ`Oz(Pmdl!?Ul>V-uXDWY8wuZ0)OM zuMS?Vx8gFv#P2y_JQzMyfosY6z@@DVuQyyM#BrH( zgDb+_Um!Wpen5VA)%P5Bjgv*?g>d_i^ZpaDLm*t}rvNGTB|55&srO8K literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/dispatcher/ArthasProcessHandler.class b/target/classes/com/pangdly/arthas/dispatcher/ArthasProcessHandler.class new file mode 100644 index 0000000000000000000000000000000000000000..2d36777923c2c7be335891f210f088e1241c9e1a GIT binary patch literal 4042 zcmbtXTXP)675;j4nbm59}n;Aa0J+r?AQo7GOR98v>?|C#^Fz+Ol|T}AD%dJ;e=T^UM!_IN72B{~pebkhA!dQTRE5nU+wi=B z^ld$Dg1}uW6vPEuv-yHGR$893+-YOZCemcqF%5ghaP#sznrs{lz$Z|LPpP;Et#rU& z%zH#oEmXHTTNxIqPheXm{wQYYnKi| zyRlE=?T|jFRWup>n*CwKcD9DEByajqw>1^K73zqMf^~I2$WWl^; z>WjW#)Q^>HdxS5OmREENo;4ti^{Qxrn!tYaDfqO&zABDXgy~VkH-;oRRXm7?Xq|^F z=LGJg^$lKyX)vJR09Dok6#{ypWO;rw9!9^40SuCSB{zSw&M58@^DzCloOAdus%xs;r79F)PqaN~}>#x^NSSLc#G3$$foo z({#CLktt6J9H?S4BybqzO7;#H6TGEp_x3i3ho z7hUJHX04c3Q3k9_GmVmGNtpy}6cj8A?5Xr@eQR`84X=r+a3pi%z7r;q1owgpS8}bv za$U!bgJmw|S?(#z)$*P;SMtjLdgq+)mbJXE*@n;QqHP(TrFC?$Or64tg44VZD(xH9 zBdel}7inmCa&mlfvp>5W!)ix#xT8PfhT{+`zUIxpEavsMZsZx z7nIz$3C}HK$lcp2l5ZUfsr%JUAgATAg_l%feV5maui+aCzRnW0DP&=nu~wgMy0lfC z!#81QJ9aRX2fSRgl&UPxXkhRjd`$TL~qmoRVu=^8OdtS?%WN zkx@ej>vhBWdp<>H6fb4lW9w`#lIZEM%&a1e0L##2F+!2VV;RdwhK5i7y0;JOJbHppv z@5o$7Jh|%))Mv8SuzNOh6?@-AN~)_1P~5>0RM1Qn+o?bz*&d2UYNMSMY3qqugMu!i+(_SzWub1EXo%L7n{3?odNP5&;`b3J(d@@B1w}svCE=hJ6dDa;_7;mub@>{es z_UCXp7;oVHU<^<20`_ukABmUZ>81JX;qmA^o?iYV^#G+G!U$WrDICC4?B?H%h#GsDi9qzf#J%8i(4Yp?QVHkhMar^_1;h(&(-p8nD zz?f*`rF9P;C!(y-IM>O!2RU~H69JnJ6B(%yu_+_&qGidZZm}IN<3)0fx!N5uFb3EMt|iTdze!6}7aa@zhkMijghJikKq z>__>0jcV#CY6p2)V3=ioXk@Hp*eYI+AZJrFVc=9`+Vt!UVyjx*RFphdwGZQS}RPRH=; F{{oVT9XtR4 literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/dispatcher/DataCache.class b/target/classes/com/pangdly/arthas/dispatcher/DataCache.class new file mode 100644 index 0000000000000000000000000000000000000000..c68ae4cbc2aa329cfc3a639785b6cf39a0b0a147 GIT binary patch literal 781 zcma)3$xgyh6g>~n4pvYU=K*KX#BPimi5rb8q6-a)%SUOTq*7CgiGSsgXrhT9;71wH zD=0)=*rac`_ndRjz3=_w#!ww&O~zLu?e&A+u}7&THs3MMdJ?&mKWp(|@;l{_Ho+^e@_)CpaIoxf3~ zfpAy+;E+tcg^eXEhTRG8V>Q3JjNGssVwlg&_ z`yrNVP;Dv`{bqXIQ>^|aHd!eC1}Lpn3v0+zg-`+WJm`dud*Z3S(%)~ltF*DgDJ1#w z0&{8<+%?`3(2?SAz+_~EksZd=H}VSW@)_wzjNkK`zyw!CV+xaTM2T_GJ)+HBWrwz( zk^4z8Vv5xTU<%U&>X^Z7kG#(UimX3ieESJ=eZCp{Nz-j+KtsnOmWVg7jC@aHD^>tB TYCK`(j_ECmj(D zb%)I(W-3dy)J=yDTWL>2IO_~(XzFm>fs~mu(}PxuD+3vd@Ven}s)J9K+oqvF`J1_(>7_wztUl2pV%Vbj>nY_mkWKeQ}B2<{$of)uAuiz5kiOKR? zlpJ(>F0_@mT(1N%Iz29+nlWiJe zs`;tb;=R>at)bByv|?$&j#z&tYsIoO70cvfcivTlBvLxoXjnEI0VVm?VjZiVvHKkj zs{+5W8-koGRq*?xE#9l+8gi{1#2zz0$cjd>-cQvg4Qtd8M77oGPYtP_Qt=i=j25Sn`ag-qA(1tQ z5A~VNYc*W0W<>_(yHyh&?~P(7cI()sVTsy>vT?S{xpp&~%D@e{k&WG-vHNad{quY6 zeP()yBc<#|wW|auJ6yyy&3%7Fw&O--q_nvEn3#p!O%2#$=cvtbMtj{JIoRWx zX@)Y#vORZ%SJv(LaZU`SSbm8~is524m#F!iR7-9ZxniX>T&09jf?ZCG293_IP@I*Z zve7rss;u_?Bn)Co%#-0Ub#epMk=OAYu9hpxS2|7<>7($w+)wKTaTRcr+{6#+cphU^ zJKwZz$1_E)Q*@ByRv5)Sc%hCLXjoKkwn|F|UW6AD96M)wNq>g3McIbps;tGxHBx@@ z%&5!Zac8(*4bLyMl5|15nGK1}aKP6)JbHt-glA+z%=kUTGtv})#xGeu6;w;6al-l3t!wvO(#^PXvo4qH&1YLaOs z-% ziZ6+wEY>w7R3|}^6^lKCu5(m;D)6|+Y6K_y%X}D2+nF35(Qc>UrY&(wA-;-lur*@z za9-|k9FM!0ne&sDkK&v7wvKOUSY94Z8T*JcWTiUfd5VH&;LyN#@LiUTd@C+#cvKBA z(DaS(G3`E{mzp~qXQ)syjHc$HLQxV$NzxO4>AO_t-c((6P6Tgvn%Qi3hNqL-Dtx03 zXQDhN|IolTZ0Euc>TqAM_A>)d#nZU+#Tru(ZEaa zQm*}>PLS8wYulD9r#QUbCO*Wx;YtL6vXX5NJ; zJs)k@LVMTKYD^|fNVS)w+DlSf5w430a`2tV#9F=y@mjSyF@_zJQ?WuxMHTVvg+^`C zDA0b4zUEN7ZS@#BI$KAvzbknO)ya!z5IHx2TY=4yAnFQd462Lk3(^d$i%Fa09)xGi73_(N{SNeScCQazYCkNn+dp4LfqiPfFmGE zjU4WvmyuQipamwprcdAaXij^hIHJi z<1T1Ah9Zogtr5h(mqrAS8WNXaB@a3vX2j z&kJu8X=Qi$X0=t+6wEqx0jEiwmv@cf6_+qS$r8P86mL3oE-mh_c{Ght>fLQscx-uqKKAvO&9$H3avM&NcK7nbRkWl}(^G7e zQ%qtttMp}jg|<)d4`ZS_;bJZRg+?8x^~d?y6_!O|E$)%EsG-nTX)1)T;p@DLPWc|! pzK-LP+ahr4yMoN;@Z%Nxja!m~74fO+tSz z-=#=cAnu;#T6sb{(*E9>ydXRdXElB=Qh8$waie@}(g!QEOxy8korJ68g;=|f30+Rw z$_Ufptn3nc8>dmdS9LtQ-sVbYt4c1w9$`@0{@f5coV_VdIH`;-Wt*4b!WR|9U#%yJ zbdF0`C_7;srP42~CS3l*GZ*~_g9tZ*2 djCWQjpIt_J*#CnZpiy#g$m|CC%sN_6$KS+=#^Gf1L`c3f3b^Dsl&NB_ zoI(;kGOj~z!A*wVb*g8^e@xRzim1S~QPUPdAil*VP

K2uSp+8EmMke6r+n03LE2b#v@5;Cfg(3CQ;kK(;U2g}x%i z3(M)Zgtwu)3{!Fab^g&o&DJEOCzRX>H3X(Gse2Y3YnK{%Whf4*t`$F>&w`3kcSYrK zOkQ-p?d~bQ_o9T)so>{s4&~?Dq%en)sPjCj`2TP#OL$D@Qw*qX?of9NeS{~}98GM| zIkbQ;1@c!6g;?Zhh`DkaPe7ng83toOBQ`Rg;W-^)uI2^E3=d-Q&LB*(XJ`(T{+~|d zS{)fK`Lq~f;Um;ZS1Hm?=zwAN)UJ<7!|8$|ua9%P;=n4#EYe2ed>OKk3K1lLJ$TTvBHjj7Q^VY3SCO&JxCIhC)mezLu5cT!_d z=!1Zl^oq&7sza?hegQ8N`AKTO6OIHKOOV;3nyLnW^@`zYWLv<1q3g|iZO^XVZ5_uq z3m_`Xl2vt7O}v`Wk$3j1%3Z+-SvrK1^nVEn+z?kQy$U77nM}`S8l@rA>RU9*(Np}j zwzC6V{tX?!&>(>>`fm1@I&saP0gbMsJ2Z2B*MO4W$BjaJ?*VS*kI=uIFC1X-HHP;w z@(1q!ijMZN{O`E`8V?TfFo}lqE^+|$pb5Ri>Lz_|(QVY{gLM%Ba*Y{$LQnDQ5oQUP z;ZuAT5_mzDNm}bZ!rXFUA79K5A7NpcfEN$3l)&)Mv>3#3+27bt;SZ4eK_4O$7}p`X zv5c?Dbt~HN4OYmK30czf1^H>B(f5A3rf5cxON*!qhgeOZ0Td*x5Q!mO2S{T*jDd7| zu3P=2+mSQe)>1=?qnH|O4L|;EpY;l@h-Aq=>)}I~NuPEyQs=QqUgSD$IZQp-!p09o S+!1~#AHj@EGYp=ORs9#wS{ok# literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/process/factory/ActionFactory.class b/target/classes/com/pangdly/arthas/process/factory/ActionFactory.class new file mode 100644 index 0000000000000000000000000000000000000000..6fa8b6f0fc85206e6dc0e7aafa03d6013998845c GIT binary patch literal 672 zcmb_aO-sW-5Pe%~W2@HhpP*O|t_PuDLZB22Lcv1{g12>DV@gcI?pEwy^WYEgM~Rcf zeuz2r;APpJnfK<++xh%@{{V1_LkBg63z@#~OeEoBJmo^$XJL4zQ>l#MPeR&MPkB$; zC`|_C%R!xCcPw57j|s+aAI3^rhE}NTofcW9G{fL@xTpxMj*`&r3|DUT!{ZX`^_x^# z-rhK9G8`{+s9BEp3gPowhGr0jiLeu`7;gSWjCbafo+eFM+QD#A$-9`lbcR6Piozv- z`mr#E?5RNZz0uX*xW59QHyXLV+o6-8Ez`t`C^0kTM->E}dvZHSCt9jO6q9ZHzrOuE zSJz-*SflL$>a+#xXrKlse^Gn`ExOgPNtrEdQ)HegBJGOWoqU(DM>y(Npbx$QuMWc0 literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/process/factory/ActionWrapper.class b/target/classes/com/pangdly/arthas/process/factory/ActionWrapper.class new file mode 100644 index 0000000000000000000000000000000000000000..ce414bbb3d49f97efc1c43c2f2cf1684e2ca494b GIT binary patch literal 5143 zcmc&&U2_{(8GcsU)vn~V>$JQnjN}vQ}C)5o|om6&%?YJ})=vv;`N@dAi ztped2%4cZ{ZDC-T-Z0E0Tx15A!R`z&4BV6%F1cccE3Wtxf%3e2R?^B=GOBNwX|?Y; z=XsxV-p_O5zy0_3e**Af{KP~;!=t6zc7DgLZf;brl>!YZf{D^FRNTKft0BEo-mJPo!}l~K zS64Zc+V+C2+J=VvV|d@YTp?S2FvV3jDUS-w}_sa5OLc=+}j3KFTLxs7syhI=O_V+U5&lhv4*49(I{ z*EYN~G#s&EAf@51V!7%qHMZA1f7M;DgvQiLZe`8&%QB88^<5JQfVoSSErMrhzayz8-1`9|7sXM znVqoFFS9}*F4r)|J$s0zC{NoMz+D>psJz???f9JtV!;)LM{Nw^ZXT-M4)gHD!6;9z zG3h4gArS=J^w0xw@ID6#)+AOrrh_)}OOs9cL!p%y#wU7lg6Q{ghqmz(chHO3E{ZAE zhFf9gb(}0p>&Z(Qy615l^Ek!ADY?}%f|kkCHimFd21%T;aT2Fw?nxW(#|K0@XX6+i z66q-$V@g`IF^QbaJ#AwKk7&?pteaY}<@q!~@;}?`A$B<18mh%+!-y7}!*r;r`b0+Q zse#gJHi<~9IaFFfm~4@j8uW*B?H)0pDBBZ{b;hKJ5}nIQN%gM;Zs~-D` zx&=Gp#N;_~Wy!|#aOso_%jXu)&_U-IAnx3#u*;b(cbM6x?M7CaYG#{u8ChjUI@><6 z71UI!nV`pywA-_qeWFpWYZoJCSqooe8BLEWW5P|oER0{-N7O8nI}m-1?wKAHU!1h?jgVD2 zgu|D@HSr1u-)5#wk2YPyiSN?OlVZ&GZEWMAFcxbPi&wcA#irOv_EmdqB|3JO znI0NjXO6|MvVHaYs`R7S9{=z2ILnP{P~P^|%JnjDxB1r5*(2Q z^1`^_*Z8mq%3fVA(yMNz!J5dd)Ea)tJ6jH~%#O5tL^7DS#@uQlW_grvrw&fxK{lNv zA3Z4~=}!;+5vT80PFeXElC}-0v{* z8wyF>$6wh1RCD-iD**1t`#3tDaux(2XCKjyFIT zx~ap`@fztump?4s2XVX=;SYr&S>rgtFr{)+yBPT`rGp_JQHUtS5`L9q672Sx1Y50H zJhH|I_+!!0i}5{1d)-6wmTxn1suW9cf0a-l!HI6n*gv^(>7ugp?g-I+gz zLbo$d^~x;O+MRh8bKRKpy)sMvcW36SM=>Wx8A0h5x2AH}Vdyuf{sQgiFp@W?{tRt# zI=6?9heHZaEKT#LpwIjjeUAPP?!Ezg#?klii6-J~!64*pA>|l?Nxg%i8|ZfoClv!N z6ik8^3YKFE$cjLwW5qz{3u%JR7cx#-K$!@Xb}}(gvCv0Qv0yuW0|&LYfkpfp7b&Gs!H=-UuL&P7;~7d8UdIdg6s0tN3J=dx%7CuJB}#qxBOb@6DcSfZ zZ-D10_2XaM^D~qN!pc$Ac`K?Mb*9hqOrN7IMGTwPEex2@{(}({N&aV1yibYg_axFL zKB1#Le2QP`DTbtpxb1c=#b~+BptIywX_vdKsdDFwF-pTrq)n6W`rz!Gelkq9ql2?s zOf_q8>ITf2J*+=3^JfdXEI4|!Vo3t3rGuC3cc}`gnS)Rl%vBA*tS%6>QGNlAV{1!IpjU;cTm#{@i zr)#%RrerV)7IB4Aim$ihOb~{EQ>qc=>skzwL2C zCWc`&0ZokFITgWDF<2Y9e>MV}o!~aU%R;1L9Z+d&bzh4V)7=!?y0=}XIwQc>vC1=+ z9bLpcyZ8rGpB>tH8@}Y)9vVZ}_V6XiFOk2hi2 zcc;7iVw4u`Fv^T713uQH-*&0I$+Y_1Jrj83b;lu?1;(ojs)v zqt3qo@Sol2uVbLjzaPj0?pI7tQ5nl|=kUdlo8HA}Ze|zRoTKkzJm(m@n94b+T^zW9 z?g@{!pco=c$rZgOM3OsSI>(s&5rxMSN$ylVl;jRHLP_qdRII~|MP5>D^8QHR4I&eG JGcxhV{{txQ!?gea literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/process/factory/AwareActionFactory.class b/target/classes/com/pangdly/arthas/process/factory/AwareActionFactory.class new file mode 100644 index 0000000000000000000000000000000000000000..22e4d38f75f48f6db81d22706bd7ab7ea917049a GIT binary patch literal 4003 zcmb_eX>$}+6g_V;q=!ihVT51+anKMl31k8Y2oumSibO+D69dGxGkGLUI^APW4-gPH z-1l8^-?#DuR%sBeQa|~@@)!71EK5AEyC>;MQdG38RC>Dad-vXR&t2a8?e8Cc0&q3H z(hw8aQgFtzMZ+E$wkEQM>x~+vY|(WJvQ)|*HVU5OPGq}|8LsRqc&20T2}By=0`*6X zqej-EZg&6B5n1pw)CzRW$6(Z!fJURVT@qN_f z8GQNx`aIXPM{+&$c7DJ$ibd&mw(iR9qMO=I(>A?b0;!g2C%Mdkz#TJ$|DR`NJ)U=l zWfC>0*HMQh0yQm}fdnoUXdnmaf??Z^mmZR7yKGtMHEY%+u?)*KGzct@#_O}zRVqo> z({ULZNh}q6sU)y2j3AP&+-&+X0}COrQiq0wN``66-tzd6bo-4ViwQ{eI0eHRFkDl8 zhr+lwYBF`(=EeQ2N+S0S)mA5p70byH>4kX`*b|K)Om}8pKKviwMr;yDn4WYE_AE)Q((MlAG;lSxYS_YDPP?wG>ez;BSdX?mPVY-A7NRwy zVMkTt2Z=~xJ34jj1RE$(aBR;oRX4AUGL|1T+&+0JBC311Z2La5x43fHEEt~5 zrFcj1>M((m8c5P|KPmnRQ{_m<{WwKThfRwkMqqpB$=^AL*{IhlL!3+#cu>bfcvz*z zDci)&{$z6|Jcm*7c-Qb~1xe)4-(5DXVd*CDI4PNZRXG`6E_Nny8c(VYeriTd1jc#L zs~ykicoxqwB6U5mS$7+v+*QgalHWi(1i>;sjTe-O7X?~uCy%i{r|cHw9#b96%V)>kt}@11z1wlTlE-r1C%sW;xRk^hyshCa zfh(sQ&9sj?V=~+0Q2k#2hjZcdNevdK|Y6iyl8uqXyOHDnFGgdCnalwd$ zQl;3>LqEEG{)>Uji|aG~5v zmNb0Eo5C!@<_cTG7Xqsqq` zuG3c_QB(-xx{}teqAbp@rVv51kKioPDi3>Gzr~94SSN5E8w7ek$5k87W3#|7*uJlA z{UmZ{ute=ye;(JyD9xYc`V9haUHIciG#yHHr*4j)!@i$sD?r{r%fJdov64PlVH4kT zM61xJxraWd(C@`9xRuyeF|OPA7DFG`mm+pS5kT%Vo(3Aved-IIbhmTIbUcd5F?v%> zHn+A-V&DvUB-XYH)=3PWog3vMA4wB)wHA$77vZ*f3SBeq^wB9y%x|L);V!;TLkN<3 zw@>NsA*J~c%El@vz2x$q4U>?QID7^PzRiF(6KCA7gB7Ty_jcmUlA{hXx)B*{##a6* zMqB+X=BF^{L(Je=dW7u6sFj9=al%e>e^5Va&7N9wxTa#PL+mePH01yEONn<8MjVhF z_epM75&eo5^%K@iQK0Py90SYec#Mw+So*KNhXwJkYrdw*pd@N(2k4BD+&%@ky_)3p z+{%F(I^ItMO11GvoIaF#>>Qp@t|#$y{i#VjKZ%#laxvx;6*Np2i+nemBF~oT^8E!( z(HQuvPpa_{8twu literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/process/invocation/ActionInvoke.class b/target/classes/com/pangdly/arthas/process/invocation/ActionInvoke.class new file mode 100644 index 0000000000000000000000000000000000000000..866c2daa04f9f74b9a050064a4b22ec8cd0f5aac GIT binary patch literal 2046 zcmb7F`&S!P5dJ2lEToIH>4TP1o3tg(OP01M(qJ{VMWO*J!6??pSvI$@W!a6J8&1)G zO3zVf?eX!mf0W1BN0Noo9Q+~Kz4y+{H}{)wX8-y3_dfy5;Clrz!X3le(VDuw*|7FB z-IZH+7KzbZCR;wI-Nig=M|hIj75`dOViTIt(I`5iVL_%P}p&qod~zG z)uZf`B0Dwdn)YTXS04u9k_rVwr!kHR1y=}}D9Dj|M3_)<6>k%UTS9ioob5}<8*0f} z5Jsz}EtcCm8^T@FH!ML&R=Mz2U3X1y9d5?umf0fA^efhzV7PGJ(Kg3EpUu5a1|jk2 zxgnaK%32C;5hkNVh|ZZ-_9fc2^@z)<$fLkyYzny~KR4y8lDr9fZyaOyRaC z#5;tmQL!9JG*|a5XH>k4_gG+Df3GhIQ+&IVLzfaL;(ZTpj!@|X_kUt~sTEODF^>

^+3-r*)w6;ckG7sw=iZg>C|=WD)_K=~x!(yjKOVvD z_=SpRE9v_Y&K<)Lfw(cFH(3oj#@rPvP2u|AfG#9Y;gOoujqN49>5m2l-|*n-CEd@N z8@=YVT|+D|n}oB`56hGn0%@L#1N=M1znC{1`D+#9_hBUX|1__j@H)oNvHStlLUQy4 z&gKihVXTmUiOVtk;yYa9|BD<1xP&+^v-3DcafSCLkn+#`5Da&nR~*cTVkTHyH#z(y z@5OnQ@ge`fASVS>^1ov2C9;I-D-_oYuQ0V9k5X)$7we=wAM<|GU@#a}U5Ipn?)^(|U*e%_)=&yP31N&!J_HeVb%Id*kgCL2Pyy(?X{K{mjMFzq~lg$sRFWbd9)c^nh literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/process/proxy/FactoryProxy.class b/target/classes/com/pangdly/arthas/process/proxy/FactoryProxy.class new file mode 100644 index 0000000000000000000000000000000000000000..b0fe966ceaf79b3221c072d0b5dfe04bf281d4c2 GIT binary patch literal 1992 zcmb7FYf}?R6g?dvlf+?(5y1zpK?M>J1{K$puqf+F?N&vliWGhxh6YB*nbf3%Uc zF1xiK_6PW*tUWz5kOvYasd@D6+;eW9d%E-a%fJ5tSi-u2l)$_be6Z@azqjMHEIU;D zcEhTNfg>By^RQ*D+l~st)5bi|56)>*T=~!H&#f00k4nxFRr6DsN?QRiM}< zSJAP3KTySOS@fHpSDc)j%wZhY4O|l#?-akOT+do-G-Rku+`vt?iHWb7BrsE|_IA9| z5!qCs>+e;{TUiL)GGQPiFj94W`MUXGTZT1z+oRBhDy8(c?9kQYBsi${-G+eGPeZz~ z$A#2?tQ)OWKSAu<&$Cb`e#q`g6-y^DS}J!eFSa--he~CdCx;Sd4U`2IJN4_?IbZF& ziF=r$fl2jBs{LR`V4{mEl)E0clNHZKR0}5NaGyyHsbcfd^?j{#o@e9!JT!3$Cc7&S zrPEaGOZRG%X6En{em3xgd$i9g&!N&3OF1lK#Q=4i>O_!-j;zNUDmrUko{UZWqK!OK zrnj&Rq$IB2QssNV&WJxN6d(s)0_crMQmpDo=Mm=M?0c9 zg!VM=dQClu^Sy|7z7x^HVuHAlsFc>)JZNj9)dgm#ZK*?(^rf#+0VT3Kj+3oNm1Rxo0A&b(0^cXRH0;UX~y!Efi-a&(Hi%vkZN9; zGY7j2N52=TZ;g-Ygnn4^1v)oUUB?N{cI&K8st_2wi|~9kkIU7kE(60F{Rz;flso8B i?@-smI`uucBrt4Xv#wj%CVi)(srHH5tJ(c8&)^eU5Q6dm literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/serialize/ArthasHttpRequestSerializeHandler$MethodParam.class b/target/classes/com/pangdly/arthas/serialize/ArthasHttpRequestSerializeHandler$MethodParam.class new file mode 100644 index 0000000000000000000000000000000000000000..d8ddeaa0039fd38f3c06fd9e3b5097c5bd95a84f GIT binary patch literal 4133 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 literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/serialize/convertor/ConvertProcessor.class b/target/classes/com/pangdly/arthas/serialize/convertor/ConvertProcessor.class new file mode 100644 index 0000000000000000000000000000000000000000..d0dd060bc3363b030f3200ad406435cdfd1ee747 GIT binary patch literal 6255 zcmbVQ33wc38Ga|(bauBxkL^Y84M&@7TDC1kq)7wmC8nyfC5@ki?yQSecuOo-^ycozxgNG$?mo^=6Pmk{_p?id*AQ; z|H*Uzd*UeoEAg_9G7aY@GrjRXGu^!{wKHxyxgIkc&svUcrtDo-Jef)Fu$)}RiLX^p zElwtBWwRMaM?k}r?dA?Mp5oi_&7Iq=WKPEf4a>%-GUI3{Pi49_R5oRt?zq`!CVQ+n zCEYd^^S*L>yon>rsnt-COqsiOX_(rS$6lKk^6DdQq^$ zO!ad?#J50^=cJY+7cSHgtV^csw4JM`psKn}Ltt%Yn-#_k%+fJa!|5lY+H9sx(lu}@ zW|LO8l~epRtgQ0ED&EzvYIO)2<{Hou)G)cpPFtJ$dpj*BVRoimLo!J-)n+ng9DBkE zbsqUe#ehBrp5bC&c>T3Wt1o9~(pep+X*km#MQda(-r%Ol=voamMF7gvrBK2s$C(Be zAQHr44X3#ds7usG-JnL3W;&YAS!>C4$j+lm7em?y?=h@qOjaR2w{0T z+rTN96z0=823~^*6GV!Iw_J~%)o@;upYJ#di@7(mX-q_S_Kiff{{K~~LJ~$D>UFFh zQ@E`=vpK8R!1=gol1!%O#h8y=NbcRv5x7?U}dujvU2AdWp0Ck z*NG1%iw_c+7RToWc98?v_Fzz$sFIXaP16E5aDncit&m%J0QvuiS$lx3zxdcA=gM0$z> z@Xfr*z>VJebym{uHB++wEe76-n?~1rGa62<@}ksh=6d35>~3$SR$h9$fp>UxmD5G| zPAS26X_!9prn?b&K?&k!diT6#%gzbnJ*@Lwj}`4R9kbWUSx(f>x{XGhAI)?{`$qCr zS`J%HQ8eme^|jS*KyEc~8{V&BqMaSha-rbMFfV>?oIYsac3H05*#^fkcM9(h8Q3E- z`mr&UvbxPw5O=bXa;LSsc19JcBr7q>w(E9ep*1>K#q5{-{jh4n`a=J+-CCygqgNtXowB& z*$@uP;^)S6Y*m*b9FeK7jM3v&pN_9GTCVznYSQtwF}m{A^bG?qNDH6H!&maE5&0o} zOB(98OLsnhU-e92EDqtj2EHfVDQKs2ZF1a_Zv6vM^g|72_~YW`sb7)Xpyh=h8~BN| zu271-%u{n1KNB@S*D&T_Q$mgM66qYqFAe-k`r5>8ZmaWD9l>uz)o)+jG|#Klbp$UO zc*%`vr)q(ovZMHe>}h{2NV^eUZIYpXHt-kxm0sa_&`mknoBWom#u3EdN$G_BN~u-N zN|(ONb5LO)^fI3Pp{m+F(S}vRQu2-Sw6`4XSmD~MEa~v<4WJE|;|j78E5#zR_N=^; z&tX)&jHH*Q()lTznRXZ&brKb0{hE zHZ|PMp>prLBew*^y?JNW^Y9D0LMJ-|wG4Y5Q)e~KL_OVkKAn02XB+5McG_2sJvFk^OL-ioH0*boL?!*43n=FPwR*h}S-V9Jo0 z?pv3U{N=3VD_8}WG51ZEw94*9E>&39^F zB;Ah3!2;F?Jl0D|@v%KvydOj3AwP$$0k9Z_E_%M39j=GP+ePoDd-NHqsM5B=Pwz!V`CuULb5+!R zE=85#vptIWq85n|lhAYLm_;;x4G}>aMkhytHDCJ0eteGc-HWL*h#YdCOX1~wc=NqP z%;Sk|US7V39_VD2@EWDq_CfJDW%!TQP(`MI>$ajvgrf78rY=nB;Dv_wiV9KliCYAMmU8 zvw5`QANVH~L}`=CYjsHYmuqE%XJrMMTv%x0!#<>nA`?ZTO#C-hm*GF&>Epkz00lD$ AIsgCw literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/serialize/convertor/Convertor.class b/target/classes/com/pangdly/arthas/serialize/convertor/Convertor.class new file mode 100644 index 0000000000000000000000000000000000000000..6b2db6926e7fbfdaaacaf1e731016b9595ddc299 GIT binary patch literal 324 zcmZWl%WlFj5S&c`1Eqljzkn1jxQCufRSBW?gv25F0pnU=6ynG+sPJh$^aJ=Pgo6Mf zIIJ`~`2a$qI%Bp?9mSE;T+ndARlx8nK>d!mX_$ zRHJ^9l)GZHwo-lT)RW=W+n|&sL?6lfql3>!szx9@`ELN^ud1Sk0L*6<&)3oPD8RFi K)(O3wneYf`TvrVM literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/serialize/convertor/ConvertorType$1.class b/target/classes/com/pangdly/arthas/serialize/convertor/ConvertorType$1.class new file mode 100644 index 0000000000000000000000000000000000000000..70d184f4ca27f05ae366db9d3416f032badb846f GIT binary patch literal 1345 zcmbW1+fvg|6o&sz3$>-3527NXqK2vj6cKGL*psvtiWckPZqshsFd^wAX=m^Sd=KA1 zozadLK7cRa+c>Trf=x%S=uDG8d#!IBGHd1M@9#eVtfCx3AH!PJJW`w7sMqvkm0M1O z+o~-rjqBQbp;k?!EiA{h)by#^J8p`Fl@NjqV~4!W)s~~_>K3;f+q}szdIDF3WoxGK zDxYCs1%@HwZHF69h3hTRU;5Sf_~D>Ez%Y=|49!V01eC=JLojXDL<9j0M-jnb7^4^u zVeB-QPKBx|)6@kwqL{!W5qocUvt%#2#kdY>o!fRiLhN)D=P|<&YRj~x1BPkk-J;Lc zi$%^17o)g@S*oPjav0VXpId4FP*k1xzbF1!o>LfevgRuc!`+fn#}2hMhpV!nYYY=g z%8yEOJd6bi-e4H%g5`#3IT5nllBB{gsg(VsYbP`&(c2Wbi>4dg;#Egj5whNu_!7g6 zlJ?_&eJI4T46)Mls`G{;>N3DG?#lqH@&)Go0Xz@F*ChV1r|Y6=)FWhgB-zKZ>w=$^ zW&#rueA3f(PB%Gqoxp}9H)Yp3Kk3>DO-VFOQ`hY}W488nde6@NjBz?!zD(QQkeh}_p-P7^G4w9aJI^01<>Q8P7&*&PX5`Ziv&(q=;FpK9p*VryzODW{Tu3?>pozPj~71lK%4hAlszhA8a2~S^xk5 literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/serialize/convertor/ConvertorType.class b/target/classes/com/pangdly/arthas/serialize/convertor/ConvertorType.class new file mode 100644 index 0000000000000000000000000000000000000000..dfc94c720112cceb575121d07b14b79ab390008e GIT binary patch literal 2014 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 literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/arthas/serialize/convertor/PrimitiveConvertor.class b/target/classes/com/pangdly/arthas/serialize/convertor/PrimitiveConvertor.class new file mode 100644 index 0000000000000000000000000000000000000000..62db835be2fb1b02834914c5ce9b6a1e202c9c94 GIT binary patch literal 3628 zcmbVOTUQfT6#fnba_OiL6}+KA5lK*kEw&<*id-r!-U_17T06us41}4OOsLq4ygFF1>OFuA$X!L+i2RAdxd1B%g{UMx}`oi?+U?vx6KLR+PN zXl7<`ST;KwQ9U22XrzHc^N?wo&agsvPXNKE4oE!CL_W7w=&ggmb6QwJqxNkhhDPks(1N{mwba7U$mmwWvYo_& zk+4d+T%xnHGlmWv3ge(cd(f|vW9HH$MV8gkkU*zGm>Vx~lfto}V}5!9k^8w2_9F^M zgx%2#S;I*`ItF!m`?h8ZCqFGcJoC?OXr8Z@m+cqN8aUcEM|A+O8C4s%H;T7~NG?~Roi~Yu0 z&5Qh14X@!08&v|Hv0dG+o@5}oe!3-3XEkiYcG)(h;dOy)Hj7iXl@-w&8qNt)%tI=R z&ubVJ%ZOPVvrEjG*p6$M5L?Z&T~}PtFe%nivv}UNbB1n-`P&+%#C)4)9?)FUaM`yX zGcx9io)i148r})m2Q)JpuKC`0O%uU&R(qhY?{oxn3MuKGyk5{(496%W%%a=8ZWq~i z68Z9Y@!EJN-j&XOPoXE+pVcSRmrTm3**5LyndOUm-mPvFx1fjd0jJ0MRACW}tWnUg zfEb;dnY%JB$LzKS19zBn<8DdMvEOzFS^Y94=c8B@NK;|^I;2!1ie*voI0fdRm-;9y zQP~^Z@Y5W|U4>mP)Qavbrq7#MKcQjJi2#-tW{e?~G_2x7o?v$fT&B|-POzVkV3+wZ z560;In(V%>&=rhtlRXj?H!S00+3?Bc12RbB1|u@YWw9UfqU}!LaO~`Mc&JP zv9w`nPmV91vYwR)wk10Nvp#A(9GHD6E|Efs&^8Mmao4-bn-kj z^1q4CxC}gAt8p23l)c1t12q2gSU-Q?;jUZI>h1tS)a>+accYDae&CKq{vJv_L3?j} z-%}ho9zV=ys`oLvQpX>oo0^_qY0`*ZJ`a)@XeZPj67OXi_hC2o^Lc=}4jiX8;X&dA zPV$Z5uCvNriMtI*bKS;Y(Vajae`OVQ189)BO*i=a#(COGsk?a;gp*r z&5Op*k>q1tBKf$<|0u%oR{4{~%P(Xe+A1@zu3F41 z0cPuk%;&bs%uBF}d4dwDbIdJmo@7!~??8G*9ShLJs){NSDQbgUnKjT0o1jnDiO%nj zD)cdWF1|YT3SSXl?wax-_HLQ4-J4^? euWJ)I1}X^_0t8J}1R@cF27Kc_zxA)A@BRbg?zY$f literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/constant/Constant.class b/target/classes/com/pangdly/constant/Constant.class new file mode 100644 index 0000000000000000000000000000000000000000..788513e7749d60c1cd10c6612c75692004fdc82f GIT binary patch literal 1987 zcmaKs*;3p_6oyZ;%9t(K@op@#*q8(lw#nkeS;UNh2|^l6Vr;T0J)#)|8cES;i03X3 zkeA6-s#2~zKwc(qkjgJ!xu&(i0dU;X#LfBr>8t8_F@LyYeFai@~-sJ$2V zD}EexGahA?>fmFXMi|W=@?%~JVN1r#qp_|?k44JpO6lpjo3^giysEWhx(ZD)8ujB|gbbGl1`XT7#tfs8Bu=q@ zwWhCYJBEAClM$;AqbSB`@?^hZ*)Gv^8*I0^T&AdVPaThkof zYiQLiZA14o*R|_wJFc$KEd*=vu2@dEf5h7YShY+S0X%oN0fW2wN*rY(%9h=J0)y!j z14B1A+)ahld~IN2h^U<%Fq(josTU_w=-r&-C_-0@(@bpXdc)I?^qajv8(8|jYih6`XSo&3=gC6d~w^^P^iLavFyGYbk$a`+yCdy zZ&}(`gG>#1CQ>yC1S(b5C?LHA5Hj z=s_5YHV+4(YIUa}h5ED%g@{wd4krAnJR&r6CrM*pbh~O>WGcR2_tkwKgkn#Q_0rZF zrN@_y=4FpxQl2Cz<(v-^$famy{->B;v13|Z9#EkgqwA$A@*1KzQ^o55RTT}HK8;d0 zo7R>>8;ouQ(Q$kv)Pd8vq>yi2D*Br;=_-mYc1+!I$`ZC2JxO@VJ0hP!5UIU1DDsQE z4?NAs#d z|B2r-y0r(1s{3);;o1KbRu)_+-KrUI@SsUQj&RdJld;-~_e6M36JyVVD9E6m;l+n2 zZlnr}2^yxoN&1O6qZuQJgxTw~MC$TZh`(#jhXCcoDoL@dw~#i64PiBz_EjD)B1#V~IZj zKa=<~@N6;h2D=jPfL}`d3jD3a-+_OS w_(x2NNA5l6p7WjW{7U}#>(}1_%;WPgdIV;y+Ci>v zR?EB2*E#zu%dWeXS~a)QaQDpS+ABGXkieCF^T^COw9U011bUrXSzxMIYm{?l-L&@X z95v+%t$5Dw=Zci<#-c#Dv|W0>_UxH}cq}kbs8yS;S#`He=g{sYCD3GLV?&xqQ3!;r z+O91SE4Cw-+yYfxXUD+ zN^cRqK=>%GVJwVMf$4usVco1USVKn~*99VF+x7Aim`?@b6&$nKTulFGH6l!QLPsC^ z1uhpWRr|@|!H(V7lvHKHHOq9i%tl4ZzOsKwk&mJmuj@!)SYq7NF$9gNxO8M#lgKDZ2M7hq-9n4&KIi*Qkx~-h(LRO95G@j+3X}ICtvgMyQk1!!ttZ3WkYrl~R_c z{6u2nB}RV6_)ipiFv;&IPe7;n5N;@~eBq+`u1l1pbJRG+lo2|{blZ1Oksd{e))7*a z{<>$48Qh{Ih?Mk^j))YZE^cH_ky22`>@jAI%rUaY#2MtcD#AF6F-(RNT&_vpZZJkd zMKL@iKMFBbIV8`xTtt;qT>eOqq2!SBIef>LK3XNZaxli2<6Jw(Nj3tQ_LePS zzaL59&5N=zxOzU;pQ?U9`8ORoArQ$@DNMr$oAfb#Ij%3lSom9J5$0D9g)lyOeu0j!pVFfTpZx=kh@xTu literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/server/HttpServer.class b/target/classes/com/pangdly/server/HttpServer.class new file mode 100644 index 0000000000000000000000000000000000000000..1531e8c2ba73121e713fae613454c9b08b070cd2 GIT binary patch literal 4495 zcmb_giGLJV9sj;$HIwM8(Nwk}M1}>&$E* zAoZ+PZLQX`YP~I5wMu|ZLbTw8wOa3^p8taXfQsKYJ9{LAfPN%o=J($F-Pij~UitT> zmjGHdDcwukR!g3O#MQe}X4*=7yD2T!*h@(*_Mj2L zA}m%=C$MflEjx8fr=}{FV5vaOu;JxZ7uX&v)3n9ZT{qr%Q-f@6AJ;V_ zxC5&dteWA-)aJ(^rjpcF!4>gvl5^PCHYgH(y7Fd`_TgJic z@d3l>(FaW5%XUgPdvzx**TLp(Nl#B5>(n#Bx@uS8w$?dB{x?2VujF%=uIKS90+H5}DI+68?JBrWU~wsLiYE%T3*1r8FYBdE zE$OGvBLpMZhM0UjpyEO7Bv;q)g47Y%7W-eUjN^3*cFiTX+3`knSISkf8?P5wlF=R4 z$k$T0F4NgF9D!wX_`9*cT|u*embNv^@Vqf?M7IV_mLqdW%bR7GL&@~8Wem13RnkMU z5}4iE>R=&(Bb>o~0 zBwaIb+um&29F!Gv5M8X8A=}B@C$K*-s~{?$w1rh;;?@{b!wx*G;tfa&ga@QF)-cVu z33*(>BLer8Cxh?}V`noF^yAI4B94%0tX-B!KVk|71nw+aGho}E z>p6Nx%lmO}VI6^vSPcveD;N@3Q=}-!Y{|>+@{2^p2+|B`vg^p+=9Z2`*8zcslF#O( zp{tMKxB^pPQK`Dx*^2#^Xu)P{9@WjP(M1K8(Sou*6rhoZj<>3Cz}l{|eO&|&$8ILN zj8pzrVRtQBSn^5pfb>nuD|#g^J(5*1Dy>y%ZAWWscXOh>w>5&3IHiCsw9FXNnTBqu zuy9(MaJbxr;LtbWjEcwbc3D0n%(%Qy1s?r>*)c1&z7_9O@h)jaZBI-0k%L|PS`*EE z(wpy5@i^Yg)4}M!7Rp3AweZd)l!~kdRq@C?oDdLkVK80u5 z2L{rX-_Tf0MQ6-nzCY__9V1?g&)_))pPi@n^O!0=htHF>J7%TWTFQInjX8f&2JA}$ ztL8zESK})J(YBtR?uNWkO%12dG-(LF;t;W}=fdnIX0pC>c4PJkK zQ{ioN`2`8d|%GQO|i3N^ouYGysF_yK;%VcH$ZdV}@}>i~PCF_bk;cE1^Sr9U`u zd`@K@hgXvpq!x{qC!GIhOk?>mqc}Zr7F%0N(i>C|yT0pxEC^Kew=*45cGhA<1>sP} zb_j9|W?tSqH>(?uHWXhoV7sn=m(Eb7kkvDtLi}3!xnMW}1*wC(mA#-Oy|_F3#wCM_ z)QG^!5^h0K3$5op&mrSw1%E6L(A;iO@TZvrzyGPD;4d=<*`5){K9Qf;BS|~!qzpNu zaiA}Kf^C&GgteTbEBVpn}geBwvelgyd>Hf5WI)vWMYhOWhc7?c<@; zX5pp@+_h=*MKo^OauJ&)uL_@69Tf%9L%56T#i&lB&$A&&f_Kg3*<0u6HVfDIQwZ&2s3&|kGiEE@sbM)ki0b(#fOWW^ z!FhnY5AwN_+0w+>JC06%BlKe*2d!3eYQqVBELOikOE5>Z?w)QQ&us9sdz zCwQ4@uufFqr+9@pG5iZZBNU>hi|}*G4O71>_yuHgSeU@C2vt$n$MI|YhPJ*+OMi>s zQIbsKC!s9AM!UlbMJf0_m8FN+uDDk4hvLrDs43e~aM}N_D>Sx3!371cNva#-ROWFM YR9>TtmFrkZVSipi4u7Ri75LkK01gNOmH+?% literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/util/ArthasUtil.class b/target/classes/com/pangdly/util/ArthasUtil.class new file mode 100644 index 0000000000000000000000000000000000000000..d0486eec581002c0e7fccadd501102ef0b23ac80 GIT binary patch literal 9355 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 J+#s02<~Q(serf;! literal 0 HcmV?d00001 diff --git a/target/classes/com/pangdly/util/SpringUtil.class b/target/classes/com/pangdly/util/SpringUtil.class new file mode 100644 index 0000000000000000000000000000000000000000..50bb2ac4c3f23ccc143e5fd74be8a4f7c52b866d GIT binary patch literal 1220 zcmb7D+j7!S6kUf~BtSW)NZfLwz_jx!QB4;MUp^&Kx6xgbECc|z!G7KBFDN8bb_9ox8 z2d<1pYNU^wz2~zrt(i>CUa!$=)Oau94(@5VE3k7B^8YVU0XMKIkTo57b|z4oDw}{6 zsQf+gQ~%G@EB^*3c-T$O=6ue2*Bb?glSwYB)|3rfnH-Ts1=Nnt%UmKa!$6I7C*adCxygDeySc9y=IaoJmO%023ei%vN8 vZ@8U;0+pU3v^qsdC;Tn?AMhj;mE|EdE+_#f6z9TRBh2-=Fa>H%m_q$Gg5?}? literal 0 HcmV?d00001 diff --git a/target/classes/log4j2.xml b/target/classes/log4j2.xml new file mode 100644 index 0000000..a78022a --- /dev/null +++ b/target/classes/log4j2.xml @@ -0,0 +1,53 @@ + + + + + http.netty.log + /mnt/default_logs + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/target/maven-archiver/pom.properties b/target/maven-archiver/pom.properties new file mode 100644 index 0000000..1dd4f9b --- /dev/null +++ b/target/maven-archiver/pom.properties @@ -0,0 +1,5 @@ +#Generated by Maven +#Mon Dec 11 13:09:25 CST 2017 +version=0.0.1-SNAPSHOT +groupId=com.pangdly +artifactId=Http.Netty diff --git a/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst b/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst new file mode 100644 index 0000000..e69de29 diff --git a/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst b/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst new file mode 100644 index 0000000..b2ba36e --- /dev/null +++ b/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst @@ -0,0 +1,40 @@ +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\annotation\ContentType.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\codec\ArthasHttpResponseEncode.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\codec\ArthasHttpRequestDecodeHandler.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\process\context\Context.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\process\factory\AwareActionFactory.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\serialize\convertor\ModelConvertor.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\process\context\ActionContext.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\process\factory\ActionFactory.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\codec\ArthasHttpRequestDecode.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\process\invocation\ActionInvoke.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\process\invocation\Invoke.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\util\Assert.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\codec\ArthasHttpResponseEncodeHandler.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\dispatcher\ArthasHttpHandler.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\process\context\XmlConfigFileActionContext.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\annotation\Action.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\dispatcher\ArthasProcess.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\serialize\convertor\ConvertProcessor.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\exception\ArthasException.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\annotation\PathParam.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\dispatcher\DataCache.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\serialize\ArthasSerialize.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\serialize\convertor\ArrayConvertor.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\serialize\ArthasHttpRequestSerializeHandler.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\process\factory\ActionWrapper.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\process\proxy\FactoryProxy.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\annotation\Mapping.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\server\HttpServer.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\annotation\RequestType.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\util\ArthasUtil.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\util\SpringUtil.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\annotation\ResponseType.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\serialize\convertor\PrimitiveConvertor.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\serialize\convertor\Convertor.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\constant\Constant.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\dispatcher\ArthasProcessHandler.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\serialize\convertor\ConvertorType.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\dispatcher\ArthasChannelInitializer.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\codec\ArthasHttpRequest.java +F:\workspace-for big data\Http.Netty\src\main\java\com\pangdly\arthas\process\proxy\Proxy.java diff --git a/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/createdFiles.lst b/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/createdFiles.lst new file mode 100644 index 0000000..e69de29 diff --git a/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst b/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst new file mode 100644 index 0000000..2781a0a --- /dev/null +++ b/target/maven-status/maven-compiler-plugin/testCompile/default-testCompile/inputFiles.lst @@ -0,0 +1 @@ +F:\workspace-for big data\Http.Netty\src\test\java\com\pangdly\Http\Netty\AppTest.java diff --git a/target/test-classes/com/pangdly/Http/Netty/AppTest.class b/target/test-classes/com/pangdly/Http/Netty/AppTest.class new file mode 100644 index 0000000000000000000000000000000000000000..12be0fb4d7b5f8278fb0c2025cb17675454ecc5f GIT binary patch literal 631 zcmaKp%}T>i5QWdQX;WkTtF6|51%W| zLy2?KEJQ^DlgynnXTG`l_|gp1&Z$x(rzMqoaE?c#j*OHE zgHXANhn{k-LNSo{L3r!vN>fCVkU#XebVMju-5YTy9G|V6whFyrzftQFjAn2tEo3oa zBZoX;#`T7>6%Q_C*bx^#dlcQEC;YAmJ)NhAhPw75!lwH_UxQFkOw(dC?evR*kc(nZ zaj{aZxqmIvFfmV9`m5B|ofe8HYxo61>HC&VUqn%|q^S}3#t7MJt!sg>Y-0th1dAmy zRGlzp0;77auf%ExaoCe5o?hNgFM3atV~bm}{CB{S$&u%1a(09aKR~{|`;5X9e`R2C zw35>jE6bSVd||ADjVaDpk7>-X#{_0EmwMIH3Dz5mXGMBO>5-LVKRpjvO}z9x!XheZ d-#))}HD|nF=_kTA4D2Lr_E?l65Y`g&^)G?TfE)k- literal 0 HcmV?d00001