diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..84c0c5c
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,23 @@
+#Change Log
+
+## Version 1.0.4
+*2018-01-25
+* Fix: in rare case, lancet generate illegal bytecode because of multi-thread.
+
+## Version 1.0.3
+*2018-01-24*
+* Fix: in rare case, lancet generate illegal bytecode because of multi-thread.
+* Add an option to open/close incremental build.
+
+## Version 1.0.2
+*2017-9-11* 
+* Fix: fall back when runtime exception occurs during process class bytes.
+
+## Version 1.0.0
+*2017-07-14*
+* Remove guava and android plugin dependency.
+* Fix: when multiple proxy appear in one method, only one works.
+
+## Version 1.0.0-beta1
+*2017-05-31*
+* Initial release.
\ No newline at end of file
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..6723610
--- /dev/null
+++ b/README.md
@@ -0,0 +1,383 @@
+# Lancet
+
+[Chinese README](README_zh.md)
+
+Lancet is a lightweight AOP framework for Android.
+
+It's fast and just take up a little time during compiling. Also, it supports incremental compiling.
+
+But it provides great api to help you coding in Android.
+
+It takes no runtime jar.
+
+In addition, not only App developers but also SDK developers can use Lancet.
+
+## Usage
+### Installation
+
+Firstly, add following code in root **build.gradle** of your project.
+
+```groovy
+dependencies{
+    classpath 'me.ele:lancet-plugin:1.0.4'
+}
+```
+And then, add following code in your **application module's build.gradle**
+
+```groovy
+apply plugin: 'me.ele.lancet'
+
+dependencies {
+    provided 'me.ele:lancet-base:1.0.4'
+}
+```
+
+That's OK.Now you can follow our tutorial to learn how to use it.
+
+### Tutorial
+
+Lancet use annotation to indicate where to cut the code and focus on interacting with origin class's methods and fields;
+
+Firstly, let's see a example.
+Look at the following code:
+
+```java
+@Proxy("i")
+@TargetClass("android.util.Log")
+public static int anyName(String tag, String msg){
+    msg = msg + "lancet";
+    return (int) Origin.call();
+}
+```
+
+There are some key points: 
+
+* ```@TargetClass``` directly locate the target ```android.util.Log```
+* ```@Proxy```locate the method name```i```
+* ```Origin.call()``` will be replaced by```Log.i()``` as we explained above
+* so the influence is every ```Log.i```'s second parameter```msg``` will has a trailing **"lancet"**
+
+
+### Choose target class
+
+```java
+public @interface TargetClass {
+    String value();
+
+    Scope scope() default Scope.SELF;
+}
+
+public @interface ImplementedInterface {
+
+    String[] value();
+
+    Scope scope() default Scope.SELF;
+}
+
+public enum Scope {
+
+    SELF,
+    DIRECT,
+    ALL,
+    LEAF
+}
+```
+We use the three classes above to locate our targets.
+
+#### @TargetClass
+
+ 1. **value** in ```@TargetClass``` should be a full class name.
+ 2. Scope.SELF means the target is the class named by **value**
+ 3. Scope.DIRECT locate the direct subclasses of **value**
+ 4. Scope.All indicates the all subclasses of **value**
+ 5. The Scope.LEAF is a little bit special, it means all leaf subclasses of **value**.For example: ```A <- B <- C, B <- D```, the leaf children of A are C and D.
+
+#### @ImplementedInterface
+
+1. **value** in ```@ImplementedInterface``` is a string array filled with full interface names and classes that satisfied all conditions will be chosen.
+2. Scope.SELF : all classes implements interfaces **literally**
+3. Scope.DIRECT : all classes implements interfaces or their children interfaces **literally**
+4. Scope.ALL: all classes included in *Scope.DIRECT* and their childrens
+5. Scope.LEAF: all classes in *Scope.ALL* with no children.
+
+Let's see a illustration.
+
+![scope](media/14948409810841/scope.png)
+
+When we use```@ImplementedInterface(value = "I", scope = ...)```, the targets are:
+
+* Scope.SELF -> A
+* Scope.DIRECT -> A C
+* Scope.ALL -> A B C D
+* Scope.LEAF -> B D
+
+
+### Choose target method
+
+#### Choose method name
+
+```java
+public @interface Insert {
+    String value();
+    boolean mayCreateSuper() default false;
+}
+
+public @interface Proxy {
+    String value();
+}
+
+public @interface TryCatchHandler {
+}
+
+public @interface NameRegex {
+    String value();
+}
+
+```
+
+##### @TryCatchHandler
+
+This annotation is easy.
+
+```java
+@TryCatchHandler
+@NameRegex("(?!me/ele/).*")
+    public static Throwable catches(Throwable t){
+        return t;
+    }
+```
+
+As the code above, it hook every try catch handle, you can deal with and return. And the control flow will jump to it's origin space.
+
+But with the ```@NameRegex```, something is different.
+
+##### @NameRegex
+
+@NameRegex is used to restrict hook method by match the class name.Be caution, the *dot* in class name will be replaced by *slash*.
+
+String value in @NameRegex will be compiled to pattern. the hook method only works if the pattern matches the class name where appear the cut point.
+
+Such as the above example, every class will be ignored if it's package name start with "me.ele.";
+
+@NameRegex can only be used with @Proxy or @TryCatchHandler.
+
+##### @Proxy and @Insert
+
+1. **Value** in ```@Proxy``` and ```@Insert``` is the target method name.
+2. ```@Proxy``` means to hook every invoke point of the target method.
+
+3. ```@Insert``` means to hook the code inside the method.
+4. In another word, if you use @Insert to hook a method, the running code in the target method will be changed.But ```@Proxy``` can control the scope by using it combined with ```@NameRegex```.
+5. Another different is, classes in Android's ROM can't be touched as compiling time.So we can't use @Insert if we want to change the behavior of ROM's classes, but @Proxy can do it.
+
+@Insert has a special boolean parameter is ```mayCreateSuper```.Let's see a example.
+
+```java
+
+@TargetClass(value = "android.support.v7.app.AppCompatActivity", scope = Scope.LEAF)
+@Insert(value = "onStop", mayCreateSuper = true)
+protected void onStop(){
+    System.out.println("hello world");
+    Origin.callVoid();
+}
+```
+
+The goal method of the hook method is 
+every leaf child of AppcompatActivity ```void onStop()```.
+
+If a class ```MyActivity extends AppcompatActivity```do not override the onStop method, we will create a method for ```MyActivity``` like this:
+
+```java
+protected void onStop() {
+    super.onStop();
+}
+```
+
+And then hook the method.
+
+If you open the flag, it will always create the method if target class has no matched method no matter it has the super method or doesn't.
+
+And the public/protected/private flag is inherited from above hook method.This is the flag's only use.
+
+Also be care that 
+
+#### Choose method descriptor
+
+The example shown at first also indicates a important rule which is the strict match.The ```Log.i``` 's full descriptor is **"int Log.i(String, String)"**, more precisely "**"(Ljava/lang/String;Ljava/lang/String;)I"**". 
+
+It means our hook method should have the same method descriptor and static flag with target method.
+
+It doesn't matter if you don't known method descriptor. You can have a look at [JVM Specification Chapter 4.3](https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3) if interested.
+
+We doesn't care if parameters' generic type are the same or not.In another word, we don't care signature of method, only descriptor.
+
+Also, exceptions declaration is also ignorable.You can write them for convenience.
+
+Any other access flag will be ignored except private/protected/public/static that we said above.
+
+##### @ClassOf
+
+Sometimes, we can't directly declare a class that we can't touch as parameter of our hook method.
+
+we can use ```@ClassOf``` to do this job.
+
+Take a look at the following example:
+
+```java
+public class A {
+    protected int execute(B b){
+        return b.call();
+    }
+
+    private class B {
+
+        int call() {
+            return 0;
+        }
+    }
+}
+
+@TargetClass("com.dieyidezui.demo.A")
+@Insert("execute")
+public int hookExecute(@ClassOf("com.dieyidezui.demo.A$B") Object o) {
+    System.out.println(o);
+    return (int) Origin.call();
+}
+```
+
+We use ```@ClassOf```to locate the parameter's actual type.
+
+And the parameter declared in method should be it's super class, such as ```java.lang.Object```;
+
+value in @ClassOf should be in the form of **"(package_name.)(outer_class_name$)class_name([]...)"**, such as:
+* java.lang.Object
+* java.lang.Integer[][]
+* A[]
+* A$B
+
+if no ```@ClassOf```, the hook method's descriptor is **"(Ljava/lang/Object;)I"**. But now it is **"(Lcom/dieyidezui/demo/A$B;)I"**.
+
+So the ```hookExecute``` method can match ```A.execute```.
+
+### API
+
+Till now, we have two classes to use, they are ```Origin``` and ```This```.
+
+#### Origin
+
+```Origin``` is used to call original method.
+You can invoke its method zero or one more times if you like.
+
+##### Origin.call/callThrowOne/callThrowTwo/callThrowThree()
+This group API is used for call the original method which has return value.
+You should cast it to original type that the same with hook method descriptor's return type.
+
+##### Origin.callVoid/callVoidThrowOne/callVoidThrowTwo/callVoidThrowThree()
+
+Similar with above three methods, these methods are used for method without return value.
+
+By the way, the ```ThrowOne/ThrowTwo/ThrowThree``` are for deceiving the compiler if you want to catch some exceptions for some convenience.
+
+For example:
+
+```java
+@TargetClass("java.io.InputStream")
+@Proxy("read")
+public int read(byte[] bytes) throws IOException {
+    try {
+        return (int) Origin.<IOException>callThrowOne();
+    } catch (IOException e) {
+        e.printStackTrace();
+        throw e;
+    }
+}
+```
+
+So that on every invoke point of ```int InputStream.read(byte[])```, if ```IOException``` happens, we will see its stacktrace. 
+
+#### This
+
+##### get()
+
+This method is used for none static method to find this object.
+You can cast it to its actual type.
+
+###### putField(Object, String) / getField(String)
+
+You can directly get or put a field in the target class even if the field is protected or private!
+
+What's more! If the field name is not exists, we will create it for you!
+
+Auto box and unbox are also supported.
+
+Also, we have some restricts:
+
+* These two methods only are only allowed to use with ```@Insert``` till now.
+* You can't retrieve it's field of super class. When you try to get or put a field that it's super class has. We still will create the field for you. If the field of super class is private, it's OK. Otherwise, you will get a error at runtime.
+
+For example:
+
+```java
+package me.ele;
+public class Main {
+    private int a = 1;
+
+    public void nothing(){
+
+    }
+
+    public int getA(){
+        return a;
+    }
+}
+
+@TargetClass("me.ele.Main")
+@Insert("nothing")
+public void testThis() {
+    Log.e("debug", This.get().getClass().getName());
+    This.putField(3, "a");
+    Origin.callVoid();
+}
+
+```
+
+Then we run the following codes:
+
+```java
+Main main = new Main();
+main.nothing();
+Log.e("debug", "a = " + main.getA());
+```
+
+We will see:
+
+```
+E/debug: me.ele.Main
+E/debug: a = 3
+```
+
+## Tips
+1. Inner classes should be named like  ```package.outer_class$inner_class```
+2. SDK developer needn't to apply plugin, just ```provided me.ele:lancet-base:x.y.z```
+3. Although we support incremental compilation. But when you use ```Scope.LEAF、Scope.ALL``` or edit the hook class, the incremental judgement will be a little special. It may cause full compilation.
+
+## License
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+
+
+
+
+
+
diff --git a/README_zh.md b/README_zh.md
new file mode 100644
index 0000000..a247707
--- /dev/null
+++ b/README_zh.md
@@ -0,0 +1,292 @@
+# Lancet
+
+Lancet 是一个轻量级Android AOP框架。
+
++ 编译速度快, 并且支持增量编译.
++ 简洁的 API, 几行 Java 代码完成注入需求.
++ 没有任何多余代码插入 apk.
++ 支持用于 SDK, 可以在SDK编写注入代码来修改依赖SDK的App.
+
+## 开始使用
+### 安装
+
+在根目录的 `build.gradle` 添加:
+```groovy
+dependencies{
+    classpath 'me.ele:lancet-plugin:1.0.4'
+}
+```
+在 app 目录的'build.gradle' 添加：
+```groovy
+apply plugin: 'me.ele.lancet'
+
+dependencies {
+    provided 'me.ele:lancet-base:1.0.4'
+}
+```
+
+
+### 示例
+
+Lancet 使用注解来指定代码织入的规则与位置。
+
+首先看看基础API使用:
+
+```java
+@Proxy("i")
+@TargetClass("android.util.Log")
+public static int anyName(String tag, String msg){
+    msg = msg + "lancet";
+    return (int) Origin.call();
+}
+```
+
+这里有几个关键点:
+
+* ```@TargetClass``` 指定了将要被织入代码目标类 ```android.util.Log```.
+* ```@Proxy``` 指定了将要被织入代码目标方法 ```i```.
+* 织入方式为`Proxy`(将在后面介绍).
+* ```Origin.call()``` 代表了 ```Log.i()``` 这个目标方法.
+
+所以这个示例Hook方法的作用就是 将代码里出现的所有 ```Log.i(tag,msg)``` 代码替换为```Log.i(tag,msg + "lancet")```
+
+### 代码织入方式
+
+#### @Proxy 
+```java
+public @interface Proxy {
+    String value();
+}
+```
+
+`@Proxy` 将使用新的方法**替换**代码里存在的原有的目标方法.   
+比如代码里有10个地方调用了 `Dog.bark()`, 代理这个方法后，所有的10个地方的代码会变为`_Lancet.xxxx.bark()`. 而在这个新方法中会执行你在Hook方法中所写的代码.  
+`@Proxy` 通常用与对系统 API 的劫持。因为虽然我们不能注入代码到系统提供的库之中，但我们可以劫持掉所有调用系统API的地方。  
+
+##### @NameRegex
+@NameRegex 用来限制范围操作的作用域. 仅用于`Proxy`模式中, 比如你只想代理掉某一个包名下所有的目标操作. 或者你在代理所有的网络请求时，不想代理掉自己发起的请求. 使用`NameRegex`对 `TargetClass` , `ImplementedInterface` 筛选出的class再进行一次匹配. 
+
+
+
+#### @Insert 
+``` java
+public @interface Insert {
+    String value();
+    boolean mayCreateSuper() default false;
+}
+```
+
+`@Insert` 将新代码插入到目标方法原有代码前后。  
+`@Insert` 常用于操作App与library的类，并且可以通过`This`操作目标类的私有属性与方法(下文将会介绍)。  
+`@Insert` 当目标方法不存在时，还可以使用`mayCreateSuper`参数来创建目标方法。  
+比如下面将代码注入每一个Activity的`onStop`生命周期  
+
+```java
+
+@TargetClass(value = "android.support.v7.app.AppCompatActivity", scope = Scope.LEAF)
+@Insert(value = "onStop", mayCreateSuper = true)
+protected void onStop(){
+    System.out.println("hello world");
+    Origin.callVoid();
+}
+```
+
+`Scope` 将在后文介绍，这里的意为目标是 `AppCompatActivity` 的所有最终子类。  
+如果一个类 `MyActivity extends AppcompatActivity` 没有重写 `onStop` 会自动创建`onStop`方法，而`Origin`在这里就代表了`super.onStop()`, 最后就是这样的效果：
+
+```java
+protected void onStop() {
+    System.out.println("hello world");
+    super.onStop();
+}
+```
+
+Note：public/protected/private 修饰符会完全照搬 Hook 方法的修饰符。
+
+
+### 匹配目标类
+
+```java
+public @interface TargetClass {
+    String value();
+
+    Scope scope() default Scope.SELF;
+}
+
+public @interface ImplementedInterface {
+
+    String[] value();
+
+    Scope scope() default Scope.SELF;
+}
+
+public enum Scope {
+
+    SELF,
+    DIRECT,
+    ALL,
+    LEAF
+}
+```
+
+很多情况，我们不会仅匹配一个类，会有注入某各类所有子类，或者实现某个接口的所有类等需求。所以通过 `TargetClass` , `ImplementedInterface` 2个注解及 `Scope` 进行目标类匹配。
+
+#### @TargetClass
+通过类查找.
+ 1. `@TargetClass` 的 `value` 是一个类的全称.
+ 2. Scope.SELF 代表仅匹配 `value` 指定的目标类.
+ 3. Scope.DIRECT 代表匹配 `value` 指定类的直接子类.
+ 4. Scope.All 代表匹配 `value` 指定类的所有子类.
+ 5. Scope.LEAF 代表匹配 `value` 指定类的最终子类.众所周知java是单继承，所以继承关系是树形结构，所以这里代表了指定类为顶点的继承树的所有叶子节点.
+
+#### @ImplementedInterface
+通过接口查找. 情况比通过类查找稍复杂一些.
+1. `@ImplementedInterface` 的 `value` 可以填写多个接口的全名.
+2. Scope.SELF : 代表直接实现所有指定接口的类.
+3. Scope.DIRECT : 代表直接实现所有指定接口，以及指定接口的子接口的类.
+4. Scope.ALL: 代表 `Scope.DIRECT` 指定的所有类及他们的所有子类.
+5. Scope.LEAF: 代表 `Scope.ALL` 指定的森林结构中的所有叶节点.
+
+如下图：
+![scope](media/14948409810841/scope.png)
+
+当我们使用`@ImplementedInterface(value = "I", scope = ...)`时, 目标类如下:
+
+* Scope.SELF -> A
+* Scope.DIRECT -> A C
+* Scope.ALL -> A B C D
+* Scope.LEAF -> B D
+
+
+### 匹配目标方法
+虽然在 `Proxy` , `Insert` 中我们指定了方法名, 但识别方法必须要更细致的信息. 我们会直接使用 Hook 方法的修饰符，参数类型来匹配方法.  
+所以一定要保持 Hook 方法的 `public/protected/private` `static` 信息与目标方法一致，参数类型，返回类型与目标方法一致.  
+返回类型可以用 Object 代替.  
+方法名不限. 异常声明也不限.  
+
+但有时候我们并没有权限声明目标类. 这时候怎么办？  
+##### @ClassOf
+可以使用 `ClassOf` 注解来替代对类的直接 import.  
+比如下面这个例子：  
+```java
+public class A {
+    protected int execute(B b){
+        return b.call();
+    }
+
+    private class B {
+
+        int call() {
+            return 0;
+        }
+    }
+}
+
+@TargetClass("com.dieyidezui.demo.A")
+@Insert("execute")
+public int hookExecute(@ClassOf("com.dieyidezui.demo.A$B") Object o) {
+    System.out.println(o);
+    return (int) Origin.call();
+}
+```
+
+`ClassOf` 的 value 一定要按照 **`(package_name.)(outer_class_name$)inner_class_name([]...)`**的模板.  
+比如:
+* java.lang.Object
+* java.lang.Integer[][]
+* A[]
+* A$B
+
+### API
+我们可以通过 `Origin` 与 `This` 与目标类进行一些交互.  
+
+#### Origin
+`Origin` 用来调用原目标方法. 可以被多次调用.  
+`Origin.call()` 用来调用有返回值的方法.  
+`Origin.callVoid()` 用来调用没有返回值的方法.  
+另外，如果你有捕捉异常的需求.可以使用  
+`Origin.call/callThrowOne/callThrowTwo/callThrowThree()`
+`Origin.callVoid/callVoidThrowOne/callVoidThrowTwo/callVoidThrowThree()`
+
+For example:
+
+```java
+@TargetClass("java.io.InputStream")
+@Proxy("read")
+public int read(byte[] bytes) throws IOException {
+    try {
+        return (int) Origin.<IOException>callThrowOne();
+    } catch (IOException e) {
+        e.printStackTrace();
+        throw e;
+    }
+}
+```
+
+
+#### This
+仅用于`Insert` 方式的非静态方法的Hook中.(暂时)  
+
+##### get()
+返回目标方法被调用的实例化对象.  
+
+###### putField & getField
+你可以直接存取目标类的所有属性，无论是 `protected` or `private`.  
+另外，如果这个属性不存在，我们还会自动创建这个属性. Exciting!  
+自动装箱拆箱肯定也支持了.  
+
+一些已知的缺陷:  
++ `Proxy` 不能使用 `This`
++ 你不能存取你父类的属性. 当你尝试存取父类属性时，我们还是会创建新的属性.
+
+For example:
+
+```java
+package me.ele;
+public class Main {
+    private int a = 1;
+
+    public void nothing(){
+
+    }
+
+    public int getA(){
+        return a;
+    }
+}
+
+@TargetClass("me.ele.Main")
+@Insert("nothing")
+public void testThis() {
+    Log.e("debug", This.get().getClass().getName());
+    This.putField(3, "a");
+    Origin.callVoid();
+}
+
+```
+
+## Tips
+1. 内部类应该命名为  ```package.outer_class$inner_class```  
+2. SDK 开发者不需要 `apply` 插件, 只需要 ```provided me.ele:lancet-base:x.y.z```  
+3. 尽管我们支持增量编译. 但当我们使用 ```Scope.LEAF、Scope.ALL``` 覆盖的类有变动 或者修改 Hook 类时, 本次编译将会变成全量编译.  
+
+## License
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+
+
+
+
+
+
diff --git a/TODO.md b/TODO.md
new file mode 100644
index 0000000..41449e2
--- /dev/null
+++ b/TODO.md
@@ -0,0 +1,7 @@
+# TODOList
++ meta.json in parser use json format and support version compatible
++ split PlaceHolder's function
++ support private field and method invoke.
++ support dynamically create field and method.
++ auto compile base and processor module
++ write unit test
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 0000000..fd14310
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,156 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+apply plugin: 'base'
+buildscript {
+    ext {
+        Properties properties = new Properties()
+        properties.load(project.rootProject.file('local.properties').newDataInputStream())
+
+        ele = true
+        ele = "true" == properties.getProperty("ele")
+
+        if (!ele) {
+            bintrayUser = properties.getProperty('bintrayUser')
+            bintrayKey = properties.getProperty('bintrayKey')
+        }
+        lancet_group = 'me.ele'
+        lancet_version = '1.0.4'
+        //lancet_version = '0.0.1.8-SNAPSHOT'
+
+        asm_version = '7.0'
+        //android_tools_version = '2.4.0-alpha6'
+        android_tools_version = '3.2.1'
+        guava_version = '20.0'
+    }
+    repositories {
+        jcenter()
+        mavenCentral()
+        maven {
+            if (ele) {
+                url "http://maven.dev.elenet.me/nexus/content/groups/public"
+            } else {
+                url "https://dl.bintray.com/eleme-mt-arch/maven"
+            }
+        }
+    }
+    dependencies {
+        if (ele) {
+            classpath 'me.ele:eradle:1.7.0'
+        } else {
+            classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.7.3'
+        }
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+subprojects { pro ->
+
+    repositories {
+        jcenter()
+        mavenCentral()
+        maven {
+            url 'https://maven.google.com'
+        }
+    }
+
+    if (pro.name == 'sample-test')return
+
+    version = lancet_version
+    group = lancet_group
+
+    if (ele) {
+        apply plugin: 'eradle'
+        modifyPom {
+            project {
+                groupId lancet_group
+                artifactId pro.name
+                version lancet_version
+                packaging 'jar'
+            }
+        }
+        extraArchive {
+            sources = true
+        }
+    } else {
+        apply plugin: 'maven'
+        apply plugin: 'com.jfrog.bintray'
+        afterEvaluate {
+            task sourcesJar(type: Jar) {
+                from sourceSets.main.java.srcDirs
+                classifier = 'sources'
+            }
+
+            task javadocJar(type: Jar, dependsOn: javadoc) {
+                classifier = 'javadoc'
+                from javadoc.destinationDir
+            }
+
+            artifacts {
+                archives sourcesJar
+                archives javadocJar
+            }
+            tasks.install {
+                repositories.mavenInstaller {
+                    pom {
+                        project {
+                            packaging 'jar'
+                            licenses {
+                                license {
+                                    name 'The Apache Software License, Version 2.0'
+                                    url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+                                }
+                            }
+                            developers {
+                                developer {
+                                    id 'dieyidezui'
+                                    name '耿万鹏'
+                                    email 'dieyidezui@gmail.com'
+                                }
+                                developer {
+                                    id 'jude95'
+                                    name '朱晨曦'
+                                    email '973829691@qq.com'
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        bintray {
+            user = bintrayUser
+            key = bintrayKey
+            configurations = ['archives']
+            pkg {
+                userOrg = "eleme-mt-arch"
+                repo = "maven"
+                userOrg = "eleme-mt-arch"
+                name = pro.name    //发布到JCenter上的项目名字
+                websiteUrl = "https://github.com/eleme/lancet"
+                vcsUrl = "git@github.com:eleme/lancet.git"
+                licenses = ["Apache-2.0"]
+                publish = true
+            }
+        }
+    }
+
+}
+
+task uploadAll { task ->
+
+    task.group = 'upload'
+    gradle.projectsEvaluated {
+        task.dependsOn project.tasks.clean
+        task.dependsOn project.tasks.build
+
+        project.tasks.build.mustRunAfter project.tasks.clean
+
+        project.subprojects {
+            if (it.name != 'sample-test') {
+                Task upload = !ele ? it.tasks.bintrayUpload : it.tasks.uploadArchives;
+                task.dependsOn upload
+                upload.mustRunAfter project.tasks.build
+            }
+        }
+    }
+}
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 0000000..89196d1
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1,18 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+org.gradle.jvmargs=-Xmx1536m
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000..13372ae
Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 0000000..86a9f99
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,7 @@
+#Mon Apr 10 15:23:45 CST 2017
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.10-all.zip
+
diff --git a/gradlew b/gradlew
new file mode 100755
index 0000000..9d82f78
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 0000000..aec9973
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/lancet-base/.gitignore b/lancet-base/.gitignore
new file mode 100644
index 0000000..796b96d
--- /dev/null
+++ b/lancet-base/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/lancet-base/build.gradle b/lancet-base/build.gradle
new file mode 100644
index 0000000..608c002
--- /dev/null
+++ b/lancet-base/build.gradle
@@ -0,0 +1,10 @@
+apply plugin: 'java'
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    compile 'org.aspectj:aspectjrt:1.9.2'
+    compileOnly "com.google.code.findbugs:jsr305:3.0.2"
+}
+
+sourceCompatibility = "1.7"
+targetCompatibility = "1.7"
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/AroundContext.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/AroundContext.java
new file mode 100644
index 0000000..dac042b
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/AroundContext.java
@@ -0,0 +1,36 @@
+package com.dieyidezui.lancet.rt;
+
+import com.sun.istack.internal.Nullable;
+
+public interface AroundContext {
+
+    /**
+     * @return The Arguments of the methods, changes to it will affect {@link AroundContext#proceed()}'s arguments on Lancet.getGlobalInterceptor.
+     * But it doesn't works on hook method, because {@link AroundContext#proceed()} will collect your hook method's actual arguments as parameters.
+     */
+    Object[] getArgs();
+
+    /**
+     * @return The context where your target method called.
+     * If static, return the class of method.
+     */
+    Object getTarget();
+
+    /**
+     * @return The object when your target method executed.
+     * If static, return the class of method.
+     */
+    Object getThis();
+
+    @Nullable
+    Object proceed();
+
+    @Nullable
+    <T1 extends Throwable> Object proceedThrow1() throws T1;
+
+    @Nullable
+    <T1 extends Throwable, T2 extends Throwable> Object proceedThrow2() throws T1, T2;
+
+    @Nullable
+    <T1 extends Throwable, T2 extends Throwable, T3 extends Throwable> Object proceedThrow3() throws T1, T2, T3;
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/AutoReplaced.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/AutoReplaced.java
new file mode 100644
index 0000000..0c39403
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/AutoReplaced.java
@@ -0,0 +1,13 @@
+package com.dieyidezui.lancet.rt;
+
+import java.lang.annotation.*;
+
+/**
+ * Indicates that annotations will replace / move / transform their annotated methods' bytecode.
+ */
+@Documented
+@Retention(RetentionPolicy.SOURCE)
+@AutoReplaced
+@Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE})
+public @interface AutoReplaced {
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/Interceptor.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/Interceptor.java
new file mode 100644
index 0000000..3192f84
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/Interceptor.java
@@ -0,0 +1,6 @@
+package com.dieyidezui.lancet.rt;
+
+public interface Interceptor {
+
+    Object intercept(AroundContext context);
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/Lancet.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/Lancet.java
new file mode 100644
index 0000000..f2b7520
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/Lancet.java
@@ -0,0 +1,31 @@
+package com.dieyidezui.lancet.rt;
+
+import javax.annotation.Nullable;
+
+public class Lancet {
+
+    private static Lancet instance = new Lancet();
+
+    public static Lancet instance() {
+        return instance;
+    }
+
+    private Interceptor global;
+
+    /**
+     * Add Method Interceptor at runtime, use it carefully!
+     */
+    public void setGlobalInterceptor(@Nullable Interceptor interceptor) {
+        this.global = interceptor;
+    }
+
+    @Nullable
+    public Interceptor getGlobalInterceptor() {
+        return global;
+    }
+
+    @AutoReplaced
+    public static AroundContext getContext() {
+        throw new AssertionError("Don't invoke it outside hook method!");
+    }
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/Scope.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/Scope.java
new file mode 100644
index 0000000..5c0a102
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/Scope.java
@@ -0,0 +1,12 @@
+package com.dieyidezui.lancet.rt;
+
+/**
+ * Created by gengwanpeng on 17/5/3.
+ */
+public enum Scope {
+
+    SELF,
+    DIRECT,
+    ALL,
+    LEAF
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/ClassOf.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/ClassOf.java
new file mode 100644
index 0000000..4ebad36
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/ClassOf.java
@@ -0,0 +1,20 @@
+package com.dieyidezui.lancet.rt.annotations;
+
+import java.lang.annotation.*;
+
+/**
+ * Annotates a parameter that its actual desc is the value().
+ * The parameter should be instance of the desc of class.
+ * For example:
+ * void foo(@ClassOf("java.util.HashMap") HashMap map); // useless for @ClassOf
+ * void foo(@ClassOf("java.util.HashMap") Map map); // work
+ * void foo(@ClassOf("java.util.HashMap[]") Object obj); // work
+ * void foo(@ClassOf("java.util.HashMap[]") Map[] maps); // work
+ * void foo(@ClassOf("java.util.HashMap[]") Map map); // doesn't work
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.PARAMETER)
+public @interface ClassOf {
+    String value();
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/ImplementedInterface.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/ImplementedInterface.java
new file mode 100644
index 0000000..116bcc1
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/ImplementedInterface.java
@@ -0,0 +1,27 @@
+package com.dieyidezui.lancet.rt.annotations;
+
+import com.dieyidezui.lancet.rt.Scope;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Limit the target classes.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD})
+public @interface ImplementedInterface {
+
+    /**
+     * Interface array, java type name, $ for inner class.
+     * For example : a.b.c$d;
+     */
+    String[] value();
+
+    /**
+     * The scope of interface array.
+     */
+    Scope scope() default Scope.SELF;
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/Insert.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/Insert.java
new file mode 100644
index 0000000..ba2349e
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/Insert.java
@@ -0,0 +1,30 @@
+package com.dieyidezui.lancet.rt.annotations;
+
+import com.dieyidezui.lancet.rt.AutoReplaced;
+
+import java.lang.annotation.*;
+
+/**
+ * Indicate the hook method.
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@AutoReplaced
+public @interface Insert {
+
+    /**
+     * The target method name.
+     */
+    String value();
+
+    /**
+     * if true, create empty method which only invoke super if not exits
+     */
+    boolean mayCreateSuper() default false;
+
+    /**
+     * Priority to sort hook methods, the smaller, the higher.
+     */
+    int priority() default 0;
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/Interceptable.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/Interceptable.java
new file mode 100644
index 0000000..b376bb8
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/Interceptable.java
@@ -0,0 +1,16 @@
+package com.dieyidezui.lancet.rt.annotations;
+
+import com.dieyidezui.lancet.rt.AutoReplaced;
+import com.dieyidezui.lancet.rt.Lancet;
+
+import java.lang.annotation.*;
+
+/**
+ * Annotate a method to make it interceptable by {@link Lancet#getGlobalInterceptor()}.
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+@AutoReplaced
+public @interface Interceptable {
+}
\ No newline at end of file
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/NameRegex.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/NameRegex.java
new file mode 100644
index 0000000..01f3911
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/NameRegex.java
@@ -0,0 +1,18 @@
+package com.dieyidezui.lancet.rt.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Restrict {@link Proxy} and {@link TryCatchHandler}'s scope, only classes which matched the regex will add the hook code.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface NameRegex {
+    /**
+     * The regex to match the class name, use the internal name, dot to slash
+     */
+    String value();
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/Proxy.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/Proxy.java
new file mode 100644
index 0000000..0a899d6
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/Proxy.java
@@ -0,0 +1,24 @@
+package com.dieyidezui.lancet.rt.annotations;
+
+import com.dieyidezui.lancet.rt.AutoReplaced;
+
+import java.lang.annotation.*;
+
+/**
+ * Indicate the hook method.
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@AutoReplaced
+public @interface Proxy {
+    /**
+     * The target method name.
+     */
+    String value();
+
+    /**
+     * Priority to sort hook methods, the smaller, the higher.
+     */
+    int priority() default 0;
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/TargetClass.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/TargetClass.java
new file mode 100644
index 0000000..4417daf
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/TargetClass.java
@@ -0,0 +1,17 @@
+package com.dieyidezui.lancet.rt.annotations;
+
+import com.dieyidezui.lancet.rt.Scope;
+
+import java.lang.annotation.*;
+
+/**
+ * Limit the target classes.
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE, ElementType.METHOD})
+public @interface TargetClass {
+    String value();
+
+    Scope scope() default Scope.SELF;
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/TryCatchHandler.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/TryCatchHandler.java
new file mode 100644
index 0000000..58abbf9
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/annotations/TryCatchHandler.java
@@ -0,0 +1,17 @@
+package com.dieyidezui.lancet.rt.annotations;
+
+import com.dieyidezui.lancet.rt.AutoReplaced;
+
+import java.lang.annotation.*;
+
+/**
+ * Pre process the classes who extends {@link Throwable}.
+ * The method desc should like (A)A (A is a class that extends Throwable).
+ * Combine with {@link NameRegex} to restrict the scope.
+ */
+@Documented
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+@AutoReplaced
+public @interface TryCatchHandler {
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/internal/AroundMethodChain.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/internal/AroundMethodChain.java
new file mode 100644
index 0000000..4688e9a
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/internal/AroundMethodChain.java
@@ -0,0 +1,81 @@
+package com.dieyidezui.lancet.rt.internal;
+
+
+import com.dieyidezui.lancet.rt.AroundContext;
+import com.dieyidezui.lancet.rt.Interceptor;
+
+import javax.annotation.Nullable;
+import java.util.List;
+
+public class AroundMethodChain implements AroundContext {
+
+    private final Object target;
+    private final Object thiz;
+    private final int index;
+    private final List<Interceptor> interceptors;
+    private final Object[] args;
+
+    public AroundMethodChain(Object target, Object thiz, int index, List<Interceptor> interceptors, Object[] args) {
+        this.target = target;
+        this.thiz = thiz;
+        this.index = index;
+        this.interceptors = interceptors;
+        this.args = args;
+    }
+
+    @Nullable
+    @Override
+    public Object getTarget() {
+        return target;
+    }
+
+    @Nullable
+    @Override
+    public Object getThis() {
+        return thiz;
+    }
+
+    @Override
+    public Object[] getArgs() {
+        return args;
+    }
+
+    @Nullable
+    @Override
+    public <T1 extends Throwable> Object proceedThrow1() throws T1 {
+        return proceed();
+    }
+
+    @Nullable
+    @Override
+    public <T1 extends Throwable, T2 extends Throwable> Object proceedThrow2() throws T1, T2 {
+        return proceed();
+    }
+
+    @Nullable
+    @Override
+    public <T1 extends Throwable, T2 extends Throwable, T3 extends Throwable> Object proceedThrow3() throws T1, T2, T3 {
+        return proceed();
+    }
+
+    @Nullable
+    @Override
+    public Object proceed() {
+        return proceed(args.clone());
+    }
+
+    /**
+     * public for generated code!
+     *
+     * @param args don't clone args
+     */
+    @Nullable
+    public Object proceed(Object[] args) {
+        if (this.index > interceptors.size()) {
+            throw new AssertionError();
+        }
+        // Clone args when pass to next!
+        AroundMethodChain next = new AroundMethodChain(target, thiz, index + 1, interceptors, args);
+        return interceptors.get(index).intercept(next);
+    }
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/internal/Util.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/internal/Util.java
new file mode 100644
index 0000000..2eebf48
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/internal/Util.java
@@ -0,0 +1,4 @@
+package com.dieyidezui.lancet.rt.internal;
+
+public class Util {
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/internal/codegen/CodegenHelper.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/internal/codegen/CodegenHelper.java
new file mode 100644
index 0000000..e5c7cfd
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/internal/codegen/CodegenHelper.java
@@ -0,0 +1,46 @@
+package com.dieyidezui.lancet.rt.internal.codegen;
+
+import com.dieyidezui.lancet.rt.Interceptor;
+import com.dieyidezui.lancet.rt.Lancet;
+import com.dieyidezui.lancet.rt.AroundContext;
+import com.dieyidezui.lancet.rt.annotations.TryCatchHandler;
+import com.dieyidezui.lancet.rt.internal.AroundMethodChain;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class CodegenHelper {
+
+    /**
+     * Invoked by generated code at hook point.
+     * @param interceptorArray sorted by priority
+     */
+    public static void doAround(@Nullable Object target, @Nullable Object thiz, Object[] args, GeneratedInterceptor[] interceptorArray) {
+
+        List<Interceptor> interceptors = new ArrayList<>(interceptorArray.length + 1);
+
+        Interceptor global = Lancet.instance().getGlobalInterceptor();
+        if (global != null) {
+            interceptors.add(global);
+        }
+        interceptors.addAll(Arrays.asList(interceptorArray));
+        // Optimize for first invoke, reduce clone args once
+        new AroundMethodChain(target, thiz, 0, interceptors, null).proceed(args);
+    }
+
+    /**
+     * For {@link TryCatchHandler}
+     */
+    public static Object onThrow(@Nullable Object target, Object[] args, GeneratedInterceptor[] interceptors) {
+        return new AroundMethodChain(target, null, 0, Arrays.<Interceptor>asList(interceptors), null).proceed(args);
+    }
+
+    /**
+     * Lancet.getContext() will redirect to this method
+     */
+    public static AroundContext getContext(GeneratedInterceptor interceptor) {
+        return interceptor.getContext();
+    }
+}
diff --git a/lancet-base/src/main/java/com/dieyidezui/lancet/rt/internal/codegen/GeneratedInterceptor.java b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/internal/codegen/GeneratedInterceptor.java
new file mode 100644
index 0000000..97285b7
--- /dev/null
+++ b/lancet-base/src/main/java/com/dieyidezui/lancet/rt/internal/codegen/GeneratedInterceptor.java
@@ -0,0 +1,24 @@
+package com.dieyidezui.lancet.rt.internal.codegen;
+
+import com.dieyidezui.lancet.rt.Interceptor;
+import com.dieyidezui.lancet.rt.AroundContext;
+
+import javax.annotation.Nullable;
+
+public abstract class GeneratedInterceptor implements Interceptor {
+
+    private AroundContext context;
+
+    @Override
+    public final Object intercept(AroundContext context) {
+        this.context = context;
+        return intercept(context.getArgs());
+    }
+
+    final public AroundContext getContext() {
+        return context;
+    }
+
+    @Nullable
+    protected abstract Object intercept(Object[] args);
+}
diff --git a/lancet-plugin/.gitignore b/lancet-plugin/.gitignore
new file mode 100644
index 0000000..796b96d
--- /dev/null
+++ b/lancet-plugin/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/lancet-plugin/build.gradle b/lancet-plugin/build.gradle
new file mode 100644
index 0000000..1c7d763
--- /dev/null
+++ b/lancet-plugin/build.gradle
@@ -0,0 +1,30 @@
+apply plugin: 'java'
+
+dependencies {
+    compile fileTree(dir: 'libs', include: ['*.jar'])
+    compile gradleApi()
+    compileOnly "com.android.tools.build:gradle:$android_tools_version"
+    compile "com.google.code.gson:gson:2.8.0"
+    compile project(':lancet-weaver')
+    testCompile gradleTestKit()
+    testCompile 'junit:junit:4.12'
+}
+
+sourceCompatibility = "1.8"
+targetCompatibility = "1.8"
+
+task createClasspathManifest {
+    def outputDir = file("$buildDir/$name")
+
+    inputs.files sourceSets.main.runtimeClasspath
+    outputs.dir outputDir
+
+    doLast {
+        outputDir.mkdirs()
+        file("$outputDir/plugin-classpath.txt").text = sourceSets.main.runtimeClasspath.join("\n")
+    }
+}
+
+dependencies {
+    testRuntime files(createClasspathManifest)
+}
\ No newline at end of file
diff --git a/lancet-plugin/src/main/java/com/dieyidezui/lancet/plugin/LancetTransform.java b/lancet-plugin/src/main/java/com/dieyidezui/lancet/plugin/LancetTransform.java
new file mode 100644
index 0000000..8686ff1
--- /dev/null
+++ b/lancet-plugin/src/main/java/com/dieyidezui/lancet/plugin/LancetTransform.java
@@ -0,0 +1,39 @@
+package com.dieyidezui.lancet.plugin;
+
+import com.android.build.api.transform.QualifiedContent;
+import com.android.build.api.transform.Transform;
+import com.android.build.api.transform.TransformException;
+import com.android.build.api.transform.TransformInvocation;
+import com.android.build.gradle.internal.pipeline.TransformManager;
+
+import java.io.IOException;
+import java.util.Set;
+
+public class LancetTransform extends Transform {
+
+
+    @Override
+    public String getName() {
+        return "lancet";
+    }
+
+    @Override
+    public Set<QualifiedContent.ContentType> getInputTypes() {
+        return TransformManager.CONTENT_CLASS;
+    }
+
+    @Override
+    public Set<? super QualifiedContent.Scope> getScopes() {
+        return TransformManager.SCOPE_FULL_PROJECT;
+    }
+
+    @Override
+    public boolean isIncremental() {
+        return true;
+    }
+
+    @Override
+    public void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
+
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/LancetExtension.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/LancetExtension.java
new file mode 100644
index 0000000..35f848a
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/LancetExtension.java
@@ -0,0 +1,73 @@
+
+package me.ele.lancet.plugin;
+
+import com.google.common.base.Strings;
+import me.ele.lancet.weaver.internal.log.Log;
+
+import java.io.File;
+import java.util.Objects;
+
+public class LancetExtension {
+    private Log.Level level = Log.Level.INFO;
+    private String fileName = null;
+    private boolean incremental = true;
+
+    public void logLevel(Log.Level level) {
+        this.level = Objects.requireNonNull(level, "Log.Level is null");
+    }
+
+    public void logLevel(int level) {
+        this.level = Log.Level.values()[level];
+    }
+
+    public void logLevel(String logStr) {
+        logLevel(strToLog(logStr));
+    }
+
+    private static Log.Level strToLog(String logStr) {
+        logStr = logStr.toLowerCase();
+        switch (logStr) {
+            case "d":
+            case "debug":
+                return Log.Level.DEBUG;
+            case "i":
+            case "info":
+                return Log.Level.INFO;
+            case "w":
+            case "warn":
+                return Log.Level.WARN;
+            case "e":
+            case "error":
+                return Log.Level.ERROR;
+            default:
+                throw new IllegalArgumentException("wrong log string: " + logStr);
+        }
+    }
+
+    public void useFileLog(String fileName) {
+        if (Strings.isNullOrEmpty(fileName) || fileName.contains(File.separator)) {
+            throw new IllegalArgumentException("File name is illegal: " + fileName);
+        }
+        this.fileName = fileName;
+    }
+
+    public void setIncremental(boolean incremental) {
+        this.incremental = incremental;
+    }
+
+    public boolean getIncremental() {
+        return this.incremental;
+    }
+
+    public void incremental(boolean incremental) {
+        this.incremental = incremental;
+    }
+
+    public Log.Level getLogLevel() {
+        return level;
+    }
+
+    public String getFileName() {
+        return fileName;
+    }
+}
\ No newline at end of file
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/LancetPlugin.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/LancetPlugin.java
new file mode 100644
index 0000000..b70a145
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/LancetPlugin.java
@@ -0,0 +1,22 @@
+package me.ele.lancet.plugin;
+
+
+import com.android.build.gradle.BaseExtension;
+import org.gradle.api.Plugin;
+import org.gradle.api.Project;
+import org.gradle.api.ProjectConfigurationException;
+
+public class LancetPlugin implements Plugin<Project> {
+
+    @Override
+    public void apply(Project project) {
+        if (project.getPlugins().findPlugin("com.android.application") == null
+                && project.getPlugins().findPlugin("com.android.library") == null) {
+            throw new ProjectConfigurationException("Need android application/library plugin to be applied first", null);
+        }
+
+        BaseExtension baseExtension = (BaseExtension) project.getExtensions().getByName("android");
+        LancetExtension lancetExtension = project.getExtensions().create("lancet", LancetExtension.class);
+        baseExtension.registerTransform(new LancetTransform(project, lancetExtension));
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/LancetTransform.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/LancetTransform.java
new file mode 100644
index 0000000..f6da027
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/LancetTransform.java
@@ -0,0 +1,165 @@
+package me.ele.lancet.plugin;
+
+import com.android.build.api.transform.QualifiedContent;
+import com.android.build.api.transform.SecondaryFile;
+import com.android.build.api.transform.Transform;
+import com.android.build.api.transform.TransformException;
+import com.android.build.api.transform.TransformInvocation;
+import com.android.build.gradle.internal.pipeline.TransformManager;
+import com.google.common.base.Joiner;
+import com.google.common.base.Strings;
+import com.google.common.io.Files;
+
+import org.gradle.api.Project;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import me.ele.lancet.plugin.internal.GlobalContext;
+import me.ele.lancet.plugin.internal.LocalCache;
+import me.ele.lancet.plugin.internal.preprocess.PreClassAnalysis;
+import me.ele.lancet.plugin.internal.TransformContext;
+import me.ele.lancet.plugin.internal.TransformProcessor;
+import me.ele.lancet.plugin.internal.context.ContextReader;
+import me.ele.lancet.weaver.MetaParser;
+import me.ele.lancet.weaver.Weaver;
+import me.ele.lancet.weaver.internal.AsmWeaver;
+import me.ele.lancet.weaver.internal.entity.TransformInfo;
+import me.ele.lancet.weaver.internal.log.Impl.FileLoggerImpl;
+import me.ele.lancet.weaver.internal.log.Log;
+import me.ele.lancet.weaver.internal.parser.AsmMetaParser;
+
+class LancetTransform extends Transform {
+
+    private final LancetExtension lancetExtension;
+    private final GlobalContext global;
+    private LocalCache cache;
+
+
+    public LancetTransform(Project project, LancetExtension lancetExtension) {
+        this.lancetExtension = lancetExtension;
+        this.global = new GlobalContext(project);
+        // load the LocalCache from disk
+        this.cache = new LocalCache(global.getLancetDir());
+    }
+
+    @Override
+    public String getName() {
+        return "lancet";
+    }
+
+
+    @Override
+    public Set<QualifiedContent.ContentType> getInputTypes() {
+        return TransformManager.CONTENT_CLASS;
+    }
+
+
+    @Override
+    public Set<QualifiedContent.Scope> getScopes() {
+        return TransformManager.SCOPE_FULL_PROJECT;
+    }
+
+    @Override
+    public boolean isIncremental() {
+        return true;
+    }
+
+
+    /**
+     * @return Hook classes we found in last compilation. If they has been changed,gradle will auto go full compile.
+     */
+    @Override
+    public Collection<SecondaryFile> getSecondaryFiles() {
+        return cache.hookClassesInDir()
+                .stream()
+                .map(File::new)
+                .map(SecondaryFile::nonIncremental)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public Collection<File> getSecondaryDirectoryOutputs() {
+        return Collections.singletonList(global.getLancetDir());
+    }
+
+    @Override
+    public void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
+        initLog();
+
+        Log.i("start time: " + System.currentTimeMillis());
+
+        // collect the information this compile need
+        TransformContext context = new TransformContext(transformInvocation, global);
+
+        Log.i("after android plugin, incremental: " + context.isIncremental());
+        Log.i("now: " + System.currentTimeMillis());
+
+        boolean incremental = lancetExtension.getIncremental() && context.isIncremental();
+
+        PreClassAnalysis preClassAnalysis = new PreClassAnalysis(cache);
+
+        incremental = preClassAnalysis.execute(incremental, context);
+
+        Log.i("after pre analysis, incremental: " + incremental);
+        Log.i("now: " + System.currentTimeMillis());
+
+        MetaParser parser = createParser(context);
+        if (incremental && !context.getGraph().checkFlow()) {
+            incremental = false;
+            context.clear();
+        }
+        Log.i("after check flow, incremental: " + incremental);
+        Log.i("now: " + System.currentTimeMillis());
+
+        context.getGraph().flow().clear();
+        TransformInfo transformInfo = parser.parse(context.getHookClasses(), context.getGraph());
+
+        Weaver weaver = AsmWeaver.newInstance(transformInfo, context.getGraph());
+        new ContextReader(context).accept(incremental, new TransformProcessor(context, weaver));
+        Log.i("build successfully done");
+        Log.i("now: " + System.currentTimeMillis());
+
+        cache.saveToLocal();
+        Log.i("cache saved");
+        Log.i("now: " + System.currentTimeMillis());
+    }
+
+    private AsmMetaParser createParser(TransformContext context) {
+        URL[] urls = Stream.concat(context.getAllJars().stream(), context.getAllDirs().stream()).map(QualifiedContent::getFile)
+                .map(File::toURI)
+                .map(u -> {
+                    try {
+                        return u.toURL();
+                    } catch (MalformedURLException e) {
+                        throw new AssertionError(e);
+                    }
+                })
+                .toArray(URL[]::new);
+        Log.d("urls:\n" + Joiner.on("\n ").join(urls));
+        ClassLoader cl = URLClassLoader.newInstance(urls, null);
+        return new AsmMetaParser(cl);
+    }
+
+    private void initLog() throws IOException {
+        Log.setLevel(lancetExtension.getLogLevel());
+        if (!Strings.isNullOrEmpty(lancetExtension.getFileName())) {
+            String name = lancetExtension.getFileName();
+            if (name.contains(File.separator)) {
+                throw new IllegalArgumentException("Log file name can't contains file separator");
+            }
+            File logFile = new File(global.getLancetDir(), "log_" + lancetExtension.getFileName());
+            Files.createParentDirs(logFile);
+            Log.setImpl(FileLoggerImpl.of(logFile.getAbsolutePath()));
+        }
+    }
+}
+
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/Util.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/Util.java
new file mode 100644
index 0000000..537b9e3
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/Util.java
@@ -0,0 +1,21 @@
+package me.ele.lancet.plugin;
+
+import com.android.utils.FileUtils;
+import me.ele.lancet.weaver.internal.asm.ClassTransform;
+
+import java.io.File;
+
+/**
+ * Created by gengwanpeng on 17/5/4.
+ */
+public class Util {
+
+    public static File toSystemDependentFile(File parent, String relativePath) {
+        return new File(parent, relativePath.replace('/', File.separatorChar));
+    }
+
+    public static File toSystemDependentHookFile(File relativeRoot, String relativePath) {
+        int index = relativePath.lastIndexOf('.');
+        return toSystemDependentFile(relativeRoot, relativePath.substring(0, index) + ClassTransform.AID_INNER_CLASS_NAME + relativePath.substring(index));
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/GlobalContext.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/GlobalContext.java
new file mode 100644
index 0000000..e3fc881
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/GlobalContext.java
@@ -0,0 +1,22 @@
+package me.ele.lancet.plugin.internal;
+
+import org.gradle.api.Project;
+
+import java.io.File;
+
+/**
+ * Created by gengwanpeng on 17/4/26.
+ */
+public class GlobalContext {
+
+    private Project project;
+
+    public GlobalContext(Project project) {
+        this.project = project;
+    }
+
+
+    public File getLancetDir() {
+        return new File(project.getBuildDir(), "lancet");
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/LocalCache.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/LocalCache.java
new file mode 100644
index 0000000..846f7cb
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/LocalCache.java
@@ -0,0 +1,111 @@
+package me.ele.lancet.plugin.internal;
+
+import com.android.build.api.transform.Status;
+import com.google.common.io.Files;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonParseException;
+
+import org.apache.commons.io.Charsets;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+import java.util.List;
+import java.util.stream.Stream;
+
+import me.ele.lancet.plugin.internal.preprocess.MetaGraphGeneratorImpl;
+import me.ele.lancet.weaver.internal.graph.CheckFlow;
+import me.ele.lancet.weaver.internal.graph.ClassEntity;
+
+/**
+ * Created by gengwanpeng on 17/4/26.
+ */
+public class LocalCache {
+
+    // Persistent storage for metas
+    private File localCache;
+    private final Metas metas;
+    private Gson gson = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
+
+    public LocalCache(File dir) {
+        localCache = new File(dir, "buildCache.json");
+        metas = loadCache();
+    }
+
+    private Metas loadCache() {
+        if (localCache.exists() && localCache.isFile()) {
+            try {
+                Reader reader = Files.newReader(localCache, Charsets.UTF_8);
+                return gson.fromJson(reader, Metas.class).withoutNull();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            } catch (JsonParseException e) {
+                if (!localCache.delete()) {
+                    throw new RuntimeException("cache file has been modified, but can't delete.", e);
+                }
+            }
+        }
+        return new Metas();
+    }
+
+
+    public List<String> hookClasses() {
+        return metas.hookClasses;
+    }
+
+    public List<String> hookClassesInDir() {
+        return metas.hookClassesInDir;
+    }
+
+    public CheckFlow hookFlow() {
+        return metas.flow;
+    }
+
+
+    /**
+     * if hook class has modified.
+     * @param context TransformContext for this compile
+     * @return true if hook class hasn't modified.
+     */
+    public boolean isHookClassModified(TransformContext context) {
+        List<String> hookClasses = metas.jarsWithHookClasses;
+        return Stream.concat(context.getRemovedJars().stream(), context.getChangedJars().stream())
+                .anyMatch(jarInput -> hookClasses.contains(jarInput.getFile().getAbsolutePath()));
+    }
+
+    public void accept(MetaGraphGeneratorImpl graph) {
+        metas.classMetas.forEach(m -> graph.add(m, Status.NOTCHANGED));
+    }
+
+    public void saveToLocal() {
+        try {
+            Files.createParentDirs(localCache);
+            Writer writer = Files.newWriter(localCache, Charsets.UTF_8);
+            gson.toJson(metas.withoutNull(), Metas.class, writer);
+            writer.close();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void clear() throws IOException {
+        if (localCache.exists() && localCache.isFile() && !localCache.delete()) {
+            throw new IOException("can't delete cache file");
+        }
+    }
+
+    public void savePartially(List<ClassEntity> classMetas) {
+        metas.classMetas = classMetas;
+        saveToLocal();
+    }
+
+    public void saveFully(List<ClassEntity> classMetas, List<String> hookClasses, List<String> hookClassesInDir, List<String> jarWithHookClasses) {
+        metas.classMetas = classMetas;
+        metas.hookClasses = hookClasses;
+        metas.hookClassesInDir = hookClassesInDir;
+        metas.jarsWithHookClasses = jarWithHookClasses;
+        saveToLocal();
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/Metas.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/Metas.java
new file mode 100644
index 0000000..b54236b
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/Metas.java
@@ -0,0 +1,45 @@
+package me.ele.lancet.plugin.internal;
+
+
+import java.util.Collections;
+import java.util.List;
+
+import me.ele.lancet.weaver.internal.graph.CheckFlow;
+import me.ele.lancet.weaver.internal.graph.ClassEntity;
+
+/**
+ * Created by gengwanpeng on 17/4/26.
+ */
+class Metas {
+
+    public List<String> hookClasses = Collections.emptyList();
+
+    public List<String> hookClassesInDir = Collections.emptyList();
+
+    public List<String> jarsWithHookClasses = Collections.emptyList();
+
+    public CheckFlow flow = new CheckFlow();
+
+    public List<ClassEntity> classMetas = Collections.emptyList();
+
+
+    public Metas withoutNull() {
+        Metas shallowClone = new Metas();
+        if (hookClasses != null) {
+            shallowClone.hookClasses = hookClasses;
+        }
+        if (hookClassesInDir != null) {
+            shallowClone.hookClassesInDir = hookClassesInDir;
+        }
+        if (jarsWithHookClasses != null) {
+            shallowClone.jarsWithHookClasses = jarsWithHookClasses;
+        }
+        if (classMetas != null) {
+            shallowClone.classMetas = classMetas;
+        }
+        if (flow != null) {
+            shallowClone.flow = flow;
+        }
+        return shallowClone;
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/TransformContext.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/TransformContext.java
new file mode 100644
index 0000000..9480a85
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/TransformContext.java
@@ -0,0 +1,139 @@
+package me.ele.lancet.plugin.internal;
+
+import com.android.build.api.transform.DirectoryInput;
+import com.android.build.api.transform.Format;
+import com.android.build.api.transform.JarInput;
+import com.android.build.api.transform.QualifiedContent;
+import com.android.build.api.transform.TransformInvocation;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+import me.ele.lancet.weaver.internal.graph.Graph;
+import me.ele.lancet.weaver.internal.log.Log;
+
+/**
+ * Created by gengwanpeng on 17/4/26.
+ *
+ * A data sets collect all jar info and pre-analysis result.
+ *
+ */
+public class TransformContext {
+
+    private TransformInvocation invocation;
+
+    private Collection<JarInput> allJars;
+    private Collection<JarInput> addedJars;
+    private Collection<JarInput> removedJars;
+    private Collection<JarInput> changedJars;
+    private Collection<DirectoryInput> allDirs;
+
+    private GlobalContext global;
+    private List<String> hookClasses;
+    private Graph graph;
+
+    public TransformContext(TransformInvocation invocation, GlobalContext global) {
+        this.global = global;
+        this.invocation = invocation;
+        init();
+    }
+
+    /**
+     * start collect.
+     */
+    private void init() {
+        allJars = new ArrayList<>(invocation.getInputs().size());
+        addedJars = new ArrayList<>(invocation.getInputs().size());
+        changedJars = new ArrayList<>(invocation.getInputs().size());
+        removedJars = new ArrayList<>(invocation.getInputs().size());
+        allDirs = new ArrayList<>(invocation.getInputs().size());
+        invocation.getInputs().forEach(it -> {
+            Log.d(it.toString());
+            it.getJarInputs().forEach(j -> {
+                allJars.add(j);
+                if (invocation.isIncremental()) {
+                    switch (j.getStatus()) {
+                        case ADDED:
+                            addedJars.add(j);
+                            break;
+                        case REMOVED:
+                            removedJars.add(j);
+                            break;
+                        case CHANGED:
+                            changedJars.add(j);
+                    }
+                }
+            });
+            allDirs.addAll(it.getDirectoryInputs());
+        });
+    }
+
+
+    public boolean isIncremental() {
+        return invocation.isIncremental();
+    }
+
+    public Collection<JarInput> getAllJars() {
+        return Collections.unmodifiableCollection(allJars);
+    }
+
+    public Collection<DirectoryInput> getAllDirs() {
+        return Collections.unmodifiableCollection(allDirs);
+    }
+
+    public Collection<JarInput> getAddedJars() {
+        return Collections.unmodifiableCollection(addedJars);
+    }
+
+    public Collection<JarInput> getChangedJars() {
+        return Collections.unmodifiableCollection(changedJars);
+    }
+
+    public Collection<JarInput> getRemovedJars() {
+        return Collections.unmodifiableCollection(removedJars);
+    }
+
+    public File getRelativeFile(QualifiedContent content) {
+        return invocation.getOutputProvider().getContentLocation(content.getName(), content.getContentTypes(), content.getScopes(),
+                (content instanceof JarInput ? Format.JAR : Format.DIRECTORY));
+    }
+
+    public void clear() throws IOException {
+        invocation.getOutputProvider().deleteAll();
+    }
+
+    public GlobalContext getGlobal() {
+        return global;
+    }
+
+    public void setHookClasses(List<String> hookClasses) {
+        this.hookClasses = hookClasses;
+    }
+
+    public List<String> getHookClasses() {
+        return hookClasses;
+    }
+
+    public Graph getGraph() {
+        return graph;
+    }
+
+    public void setGraph(Graph graph) {
+        this.graph = graph;
+    }
+
+    @Override
+    public String toString() {
+        return "TransformContext{" +
+                "allJars=" + allJars +
+                ", addedJars=" + addedJars +
+                ", removedJars=" + removedJars +
+                ", changedJars=" + changedJars +
+                ", allDirs=" + allDirs +
+                '}';
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/TransformProcessor.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/TransformProcessor.java
new file mode 100644
index 0000000..dc263be
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/TransformProcessor.java
@@ -0,0 +1,129 @@
+package me.ele.lancet.plugin.internal;
+
+import com.android.build.api.transform.JarInput;
+import com.android.build.api.transform.QualifiedContent;
+import com.android.build.api.transform.Status;
+import com.android.utils.FileUtils;
+import com.google.common.io.Files;
+
+import java.io.BufferedOutputStream;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.jar.JarOutputStream;
+import java.util.zip.ZipEntry;
+
+import me.ele.lancet.plugin.Util;
+import me.ele.lancet.plugin.internal.context.ClassFetcher;
+import me.ele.lancet.weaver.ClassData;
+import me.ele.lancet.weaver.Weaver;
+import me.ele.lancet.weaver.internal.log.Log;
+
+/**
+ * Created by gengwanpeng on 17/5/4.
+ */
+public class TransformProcessor implements ClassFetcher {
+
+    private final TransformContext context;
+    private final Weaver weaver;
+    private final DirectoryRunner dirRunner = new DirectoryRunner();
+    private Map<QualifiedContent, JarRunner> map = new ConcurrentHashMap<>();
+
+    public TransformProcessor(TransformContext context, Weaver weaver) {
+        this.context = context;
+        this.weaver = weaver;
+    }
+
+    @Override
+    public boolean onStart(QualifiedContent content) throws IOException {
+        if (content instanceof JarInput) {
+            JarInput jarInput = (JarInput) content;
+            File targetFile = context.getRelativeFile(content);
+            switch (jarInput.getStatus()) {
+                case REMOVED:
+                    FileUtils.deleteIfExists(targetFile);
+                    return false;
+                case CHANGED:
+                    FileUtils.deleteIfExists(targetFile);
+                default:
+                    Files.createParentDirs(targetFile);
+                    map.put(content, new JarRunner(content, targetFile));
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public void onClassFetch(QualifiedContent content, Status status, String relativePath, byte[] bytes) throws IOException {
+        if (content instanceof JarInput) {
+            JarRunner jarRunner = map.get(content);
+            jarRunner.run(relativePath, bytes);
+        } else { // directory, so must be class
+            File relativeRoot = context.getRelativeFile(content);
+            File target = Util.toSystemDependentFile(relativeRoot, relativePath);
+            File hookWithTarget = Util.toSystemDependentHookFile(relativeRoot, relativePath);
+            switch (status) {
+                case REMOVED:
+                    FileUtils.deleteIfExists(target);
+                    FileUtils.deleteIfExists(hookWithTarget);
+                    break;
+                case CHANGED:
+                    FileUtils.deleteIfExists(target);
+                    FileUtils.deleteIfExists(hookWithTarget);
+                default:
+                    dirRunner.run(relativeRoot, relativePath, bytes);
+            }
+        }
+    }
+
+    @Override
+    public void onComplete(QualifiedContent content) throws IOException {
+        if (content instanceof JarInput && ((JarInput) content).getStatus() != Status.REMOVED) {
+            map.get(content).close();
+        }
+    }
+
+    class JarRunner implements Closeable {
+
+        private final JarOutputStream jos;
+        private final QualifiedContent content;
+
+        JarRunner(QualifiedContent content, File targetFile) throws IOException {
+            this.content = content;
+            this.jos = new JarOutputStream(
+                    new BufferedOutputStream(new FileOutputStream(targetFile)));
+        }
+
+        void run(String relativePath, byte[] bytes) throws IOException {
+            if (!relativePath.endsWith(".class")) {
+                ZipEntry entry = new ZipEntry(relativePath);
+                jos.putNextEntry(entry);
+                jos.write(bytes);
+            } else {
+                for (ClassData classData : weaver.weave(bytes, relativePath)) {
+                    ZipEntry entry = new ZipEntry(classData.getClassName() + ".class");
+                    jos.putNextEntry(entry);
+                    jos.write(classData.getClassBytes());
+                }
+            }
+        }
+
+        public void close() throws IOException {
+            jos.close();
+        }
+    }
+
+    class DirectoryRunner {
+
+        void run(File relativeRoot, String relativePath, byte[] bytes) throws IOException {
+            for (ClassData data : weaver.weave(bytes, relativePath)) {
+                File target = Util.toSystemDependentFile(relativeRoot, data.getClassName() + ".class");
+                Files.createParentDirs(target);
+                Files.write(data.getClassBytes(), target);
+            }
+        }
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/ClassFetcher.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/ClassFetcher.java
new file mode 100644
index 0000000..52e729c
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/ClassFetcher.java
@@ -0,0 +1,37 @@
+package me.ele.lancet.plugin.internal.context;
+
+import com.android.build.api.transform.QualifiedContent;
+import com.android.build.api.transform.Status;
+
+import java.io.IOException;
+
+/**
+ * The Fetcher to fetch each class in QualifiedContent
+ */
+public interface ClassFetcher {
+
+    /**
+     * begin unzip a QualifiedContent.
+     * @param content the Jar or Dir QualifiedContent.
+     * @return whether the Fetcher can accept this QualifiedContent.
+     * @throws IOException
+     */
+    boolean onStart(QualifiedContent content) throws IOException;
+
+    /**
+     * fetch each class in QualifiedContent. each invoke will in one thread.
+     * @param content
+     * @param status
+     * @param relativePath
+     * @param bytes
+     * @throws IOException
+     */
+    void onClassFetch(QualifiedContent content, Status status, String relativePath, byte[] bytes) throws IOException;
+
+    /**
+     * has finished fetch class in this QualifiedContent
+     * @param content
+     * @throws IOException
+     */
+    void onComplete(QualifiedContent content) throws IOException;
+}
\ No newline at end of file
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/ClassifiedContentProvider.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/ClassifiedContentProvider.java
new file mode 100644
index 0000000..183c4c5
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/ClassifiedContentProvider.java
@@ -0,0 +1,33 @@
+package me.ele.lancet.plugin.internal.context;
+
+import com.android.build.api.transform.QualifiedContent;
+
+import java.io.IOException;
+
+/**
+ * Created by gengwanpeng on 17/4/28.
+ *
+ * A QualifiedContentProvider proxy multiple ContentProviders.
+ *
+ */
+public class ClassifiedContentProvider implements QualifiedContentProvider {
+
+    public static ClassifiedContentProvider newInstance(TargetedQualifiedContentProvider... providers) {
+        return new ClassifiedContentProvider(providers);
+    }
+
+    private TargetedQualifiedContentProvider[] providers;
+
+    private ClassifiedContentProvider(TargetedQualifiedContentProvider... providers) {
+        this.providers = providers;
+    }
+
+    @Override
+    public void forEach(QualifiedContent content, ClassFetcher processor) throws IOException {
+        for (TargetedQualifiedContentProvider provider : providers) {
+            if(provider.accepted(content)){
+                provider.forEach(content,processor);
+            }
+        }
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/ContextReader.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/ContextReader.java
new file mode 100644
index 0000000..8d81574
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/ContextReader.java
@@ -0,0 +1,135 @@
+package me.ele.lancet.plugin.internal.context;
+
+import com.android.build.api.transform.JarInput;
+import com.android.build.api.transform.QualifiedContent;
+import com.android.build.api.transform.Status;
+import com.google.common.collect.ImmutableList;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import me.ele.lancet.plugin.internal.TransformContext;
+import me.ele.lancet.plugin.internal.preprocess.ParseFailureException;
+import me.ele.lancet.weaver.internal.log.Log;
+
+/**
+ * Created by gengwanpeng on 17/5/2.
+ *
+ * This class will unzip all jars,and accept all class with input ClassFetcher in thread pool.
+ * Used in pre-analysis and formal analysis.
+ *
+ */
+public class ContextReader {
+
+    private AtomicBoolean lock = new AtomicBoolean(false);
+    private TransformContext context;
+    private ClassifiedContentProvider provider;
+    private ExecutorService service = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), Runtime.getRuntime().availableProcessors(),
+            0L, TimeUnit.MILLISECONDS,
+            new LinkedBlockingQueue<>(), (r, executor) -> {
+        Log.i("partial parse failed, executor has been shutdown");
+    });
+
+    public ContextReader(TransformContext context) {
+        this.context = context;
+    }
+
+    /**
+     * read the classes in thread pool and send class to fetcher.
+     * @param incremental is incremental compile
+     * @param fetcher the fetcher to visit classes
+     * @throws IOException
+     * @throws InterruptedException
+     */
+    public void accept(boolean incremental, ClassFetcher fetcher) throws IOException, InterruptedException {
+
+        provider = ClassifiedContentProvider.newInstance(new JarContentProvider(), new DirectoryContentProvider(incremental));
+        // get all jars
+        Collection<JarInput> jars = !incremental ? context.getAllJars() :
+                ImmutableList.<JarInput>builder()
+                        .addAll(context.getAddedJars())
+                        .addAll(context.getRemovedJars())
+                        .addAll(changedToDeleteAndAdd())
+                        .build();
+        // accept the jar in thread pool
+        List<Future<Void>> tasks = Stream.concat(jars.stream(), context.getAllDirs().stream())
+                .map(q -> new QualifiedContentTask(q, fetcher))
+                .map(t -> service.submit(t))
+                .collect(Collectors.toList());
+
+        // block until all task has finish.
+        for (Future<Void> future : tasks) {
+            try {
+                future.get();
+            } catch (ExecutionException e) {
+                if (incremental && e.getCause() instanceof ParseFailureException) {
+                    shutDownAndRestart();
+                    continue;
+                }
+                Throwable cause = e.getCause();
+                if (cause instanceof IOException) {
+                    throw (IOException) cause;
+                } else if (cause instanceof InterruptedException) {
+                    throw (InterruptedException) cause;
+                } else {
+                    throw new RuntimeException(e.getCause());
+                }
+            }
+        }
+
+    }
+
+    /**
+     * Transform the change operation to delete & add.
+     * @return
+     */
+    private Collection<? extends JarInput> changedToDeleteAndAdd(){
+        List<JarInput> jarInputs = new ArrayList<>();
+        context.getChangedJars().stream()
+                .peek(c -> jarInputs.add(new StatusOverrideJarInput(context,c, Status.REMOVED)))
+                .peek(c -> jarInputs.add(new StatusOverrideJarInput(context,c, Status.ADDED)));
+        return jarInputs;
+    }
+
+
+
+    private void shutDownAndRestart() {
+        if (lock.compareAndSet(false, true)) {
+            service.shutdown();
+            service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
+        }
+    }
+
+    /**
+     * Task to accept target QualifiedContent
+     */
+    private class QualifiedContentTask implements Callable<Void> {
+
+        private QualifiedContent content;
+        private ClassFetcher fetcher;
+
+        QualifiedContentTask(QualifiedContent content, ClassFetcher fetcher) {
+            this.content = content;
+            this.fetcher = fetcher;
+        }
+
+        @Override
+        public Void call() throws Exception {
+            provider.forEach(content, fetcher);
+            return null;
+        }
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/DirectoryContentProvider.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/DirectoryContentProvider.java
new file mode 100644
index 0000000..c5a21b4
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/DirectoryContentProvider.java
@@ -0,0 +1,64 @@
+package me.ele.lancet.plugin.internal.context;
+
+import com.android.build.api.transform.DirectoryInput;
+import com.android.build.api.transform.QualifiedContent;
+import com.android.build.api.transform.Status;
+import com.google.common.io.Files;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URI;
+import java.util.Map;
+
+import me.ele.lancet.weaver.internal.log.Log;
+
+/**
+ * Created by gengwanpeng on 17/4/28.
+ */
+public class DirectoryContentProvider extends TargetedQualifiedContentProvider {
+
+    private final boolean incremental;
+
+    public DirectoryContentProvider(boolean incremental) {
+        this.incremental = incremental;
+    }
+
+    @Override
+    public void forEach(QualifiedContent content, ClassFetcher processor) throws IOException {
+        if (processor.onStart(content)) {
+            File root = content.getFile();
+            URI base = root.toURI();
+            if (!incremental) {
+                /**
+                 * if this compile is full compilation. we traverse all classes as newly added classes
+                 */
+                for (File f : Files.fileTreeTraverser().preOrderTraversal(root)) {
+                    if (f.isFile() && f.getName().endsWith(".class")) {
+                        byte[] data = Files.toByteArray(f);
+                        String relativePath = base.relativize(f.toURI()).toString();
+                        processor.onClassFetch(content, Status.ADDED, relativePath, data);
+                    }
+                }
+            } else {
+                /**
+                 * if this compile is incremental compilation. we traverse all changed classes.
+                 */
+                for (Map.Entry<File, Status> entry : ((DirectoryInput) content).getChangedFiles().entrySet()) {
+                    Log.d(entry.getKey() + " " + entry.getValue());
+                    File f = entry.getKey();
+                    if (f.isFile() && f.getName().endsWith(".class")) {
+                        byte[] data = Files.toByteArray(f);
+                        String relativePath = base.relativize(f.toURI()).toString();
+                        processor.onClassFetch(content, entry.getValue(), relativePath, data);
+                    }
+                }
+            }
+        }
+        processor.onComplete(content);
+    }
+
+    @Override
+    public boolean accepted(QualifiedContent qualifiedContent) {
+        return qualifiedContent instanceof DirectoryInput;
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/JarContentProvider.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/JarContentProvider.java
new file mode 100644
index 0000000..ce82179
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/JarContentProvider.java
@@ -0,0 +1,45 @@
+package me.ele.lancet.plugin.internal.context;
+
+import com.android.build.api.transform.JarInput;
+import com.android.build.api.transform.QualifiedContent;
+import com.google.common.io.ByteStreams;
+
+import org.apache.commons.io.IOUtils;
+
+import java.io.BufferedInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+/**
+ * Created by gengwanpeng on 17/4/28.
+ */
+public class JarContentProvider extends TargetedQualifiedContentProvider {
+
+    @Override
+    public void forEach(QualifiedContent content, ClassFetcher processor) throws IOException {
+        forActualInput((JarInput) content, processor);
+    }
+
+    private void forActualInput(JarInput jarInput, ClassFetcher processor) throws IOException {
+        if (processor.onStart(jarInput)) {
+            ZipInputStream zis = new ZipInputStream(new BufferedInputStream(new FileInputStream(jarInput.getFile())));
+            ZipEntry entry;
+            while ((entry = zis.getNextEntry()) != null) {
+                if (entry.isDirectory()) {
+                    continue;
+                }
+                byte[] data = ByteStreams.toByteArray(zis);
+                processor.onClassFetch(jarInput, jarInput.getStatus(), entry.getName(), data);
+            }
+            IOUtils.closeQuietly(zis);
+        }
+        processor.onComplete(jarInput);
+    }
+
+    @Override
+    public boolean accepted(QualifiedContent qualifiedContent) {
+        return qualifiedContent instanceof JarInput;
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/QualifiedContentProvider.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/QualifiedContentProvider.java
new file mode 100644
index 0000000..39d3795
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/QualifiedContentProvider.java
@@ -0,0 +1,27 @@
+package me.ele.lancet.plugin.internal.context;
+
+import com.android.build.api.transform.QualifiedContent;
+
+import java.io.IOException;
+
+/**
+ * Created by gengwanpeng on 17/4/28.
+ *
+ * Unzip QualifiedContent and provide single class for inout ClassFetcher.
+ * QualifiedContent may be one of {@link com.android.build.api.transform.JarInput} and {@link com.android.build.api.transform.DirectoryInput}.
+ * So there are tow child of QualifiedContentProvider {@link JarContentProvider} and {@link DirectoryContentProvider}
+ *
+ */
+public interface QualifiedContentProvider {
+
+    /**
+     * start accept the classes
+     * @param content
+     * @param processor
+     * @throws IOException
+     */
+    void forEach(QualifiedContent content, ClassFetcher processor) throws IOException;
+
+
+
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/StatusOverrideJarInput.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/StatusOverrideJarInput.java
new file mode 100644
index 0000000..845687e
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/StatusOverrideJarInput.java
@@ -0,0 +1,53 @@
+package me.ele.lancet.plugin.internal.context;
+
+import com.android.build.api.transform.JarInput;
+import com.android.build.api.transform.Status;
+import com.google.common.base.Charsets;
+import com.google.common.hash.Hashing;
+
+import java.io.File;
+import java.util.Set;
+
+import me.ele.lancet.plugin.internal.TransformContext;
+
+/**
+ * Created by Jude on 2017/7/14.
+ */
+
+public class StatusOverrideJarInput implements JarInput {
+    private JarInput jarInput;
+    private File jar ;
+    private Status status;
+
+
+    public StatusOverrideJarInput(TransformContext context, JarInput jarInput,Status status) {
+        this.jarInput = jarInput;
+        this.jar = context.getRelativeFile(jarInput);
+        this.status = status;
+    }
+
+    @Override
+    public Status getStatus() {
+        return status;
+    }
+
+    @Override
+    public String getName() {
+        return Hashing.sha1().hashString(jar.getPath()+status, Charsets.UTF_16LE).toString();
+    }
+
+    @Override
+    public File getFile() {
+        return jar;
+    }
+
+    @Override
+    public Set<ContentType> getContentTypes() {
+        return jarInput.getContentTypes();
+    }
+
+    @Override
+    public Set<? super Scope> getScopes() {
+        return jarInput.getScopes();
+    }
+}
\ No newline at end of file
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/TargetedQualifiedContentProvider.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/TargetedQualifiedContentProvider.java
new file mode 100644
index 0000000..e5228b3
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/context/TargetedQualifiedContentProvider.java
@@ -0,0 +1,18 @@
+package me.ele.lancet.plugin.internal.context;
+
+import com.android.build.api.transform.QualifiedContent;
+
+/**
+ * Created by gengwanpeng on 17/4/28.
+ * {@inheritDoc}
+ */
+public abstract class TargetedQualifiedContentProvider implements QualifiedContentProvider {
+
+    /**
+     * Judge the QualifiedContent type
+     * @param qualifiedContent {@link com.android.build.api.transform.JarInput} or {@link com.android.build.api.transform.DirectoryInput}
+     * @return can this provider accept this QualifiedContent.
+     */
+    public abstract boolean accepted(QualifiedContent qualifiedContent);
+
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/AsmClassProcessorImpl.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/AsmClassProcessorImpl.java
new file mode 100644
index 0000000..2d58383
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/AsmClassProcessorImpl.java
@@ -0,0 +1,20 @@
+package me.ele.lancet.plugin.internal.preprocess;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.Opcodes;
+
+import java.io.IOException;
+
+/**
+ * Created by gengwanpeng on 17/4/27.
+ */
+public class AsmClassProcessorImpl implements PreClassProcessor {
+
+    @Override
+    public PreClassProcessor.ProcessResult process(byte[] classBytes) {
+        ClassReader cr = new ClassReader(classBytes);
+        PreProcessClassVisitor cv = new PreProcessClassVisitor(Opcodes.ASM5);
+        cr.accept(cv, ClassReader.SKIP_CODE | ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
+        return cv.getProcessResult();
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/MetaGraphGeneratorImpl.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/MetaGraphGeneratorImpl.java
new file mode 100644
index 0000000..f93f4c7
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/MetaGraphGeneratorImpl.java
@@ -0,0 +1,78 @@
+package me.ele.lancet.plugin.internal.preprocess;
+
+import com.android.build.api.transform.Status;
+
+import org.objectweb.asm.Opcodes;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+
+import me.ele.lancet.weaver.internal.graph.CheckFlow;
+import me.ele.lancet.weaver.internal.graph.ClassEntity;
+import me.ele.lancet.weaver.internal.graph.ClassNode;
+import me.ele.lancet.weaver.internal.graph.Graph;
+import me.ele.lancet.weaver.internal.graph.InterfaceNode;
+import me.ele.lancet.weaver.internal.graph.MetaGraphGenerator;
+import me.ele.lancet.weaver.internal.graph.Node;
+
+/**
+ * Created by gengwanpeng on 17/4/26.
+ */
+public class MetaGraphGeneratorImpl implements MetaGraphGenerator {
+
+    private final CheckFlow checkFlow;
+    // Key is class name. value is class node.
+    private Map<String, Node> nodeMap = new ConcurrentHashMap<>(512);
+    private Graph graph;
+
+    public MetaGraphGeneratorImpl(CheckFlow checkFlow) {
+        this.checkFlow = checkFlow;
+    }
+
+    // thread safe
+    public void add(ClassEntity entity, Status status) {
+        Node current = getOrPutEmpty((entity.access & Opcodes.ACC_INTERFACE) != 0, entity.name);
+
+        ClassNode superNode = null;
+        List<InterfaceNode> interfaceNodes = Collections.emptyList();
+        if (entity.superName != null) {
+            superNode = (ClassNode) getOrPutEmpty(false, entity.superName);
+        }
+        if (entity.interfaces.size() > 0) {
+            interfaceNodes = entity.interfaces.stream().map(i -> (InterfaceNode) getOrPutEmpty(true, i)).collect(Collectors.toList());
+        }
+
+        current.entity = entity;
+        current.parent = superNode;
+        current.status = status;
+        current.interfaces = interfaceNodes;
+    }
+
+    public void remove(String className) {
+        nodeMap.remove(className);
+    }
+
+    // find node by name, if node is not exist then create and add it.
+    private Node getOrPutEmpty(boolean isInterface, String className) {
+        return nodeMap.computeIfAbsent(className, n -> isInterface ?
+                new InterfaceNode(n) :
+                new ClassNode(n));
+    }
+
+
+    List<ClassEntity> toLocalNodes() {
+        return nodeMap.values().stream().filter(it -> it.parent != null).map(it -> it.entity).collect(Collectors.toList());
+    }
+
+    @Override
+    public Graph generate() {
+        if (graph == null) {
+            graph = new Graph(nodeMap, checkFlow);
+            graph.prepare();
+        }
+        return graph;
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/ParseFailureException.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/ParseFailureException.java
new file mode 100644
index 0000000..c7aecd1
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/ParseFailureException.java
@@ -0,0 +1,21 @@
+package me.ele.lancet.plugin.internal.preprocess;
+
+/**
+ * Created by gengwanpeng on 17/5/4.
+ */
+public class ParseFailureException extends RuntimeException {
+    public ParseFailureException() {
+    }
+
+    public ParseFailureException(String message) {
+        super(message);
+    }
+
+    public ParseFailureException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public ParseFailureException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/PreClassAnalysis.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/PreClassAnalysis.java
new file mode 100644
index 0000000..dba6436
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/PreClassAnalysis.java
@@ -0,0 +1,160 @@
+package me.ele.lancet.plugin.internal.preprocess;
+
+import com.android.build.api.transform.JarInput;
+import com.android.build.api.transform.QualifiedContent;
+import com.android.build.api.transform.Status;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import me.ele.lancet.plugin.Util;
+import me.ele.lancet.plugin.internal.LocalCache;
+import me.ele.lancet.plugin.internal.TransformContext;
+import me.ele.lancet.plugin.internal.context.ClassFetcher;
+import me.ele.lancet.plugin.internal.context.ContextReader;
+import me.ele.lancet.weaver.internal.log.Log;
+
+/**
+ * Created by gengwanpeng on 17/4/26.
+ *
+ * When you see this class you may be as happy as me like this:
+ * <a href="http://wx1.sinaimg.cn/large/415f82b9ly1fe9kqcoe2nj20k00k0dhy.jpg"></a>
+ *
+ * PreClassAnalysis mainly records the dependency graph of all classes,
+ * and record the hook classes to judge if incremental compile available in next time.
+ *
+ */
+public class PreClassAnalysis {
+
+    private LocalCache cache;
+    private MetaGraphGeneratorImpl graph;
+    private PreClassProcessor classProcessor = new AsmClassProcessorImpl();
+
+
+    private ContextReader contextReader;
+
+
+    private volatile boolean partial = true;
+
+    public PreClassAnalysis(LocalCache cache) {
+        this.cache = cache;
+        this.graph = new MetaGraphGeneratorImpl(cache.hookFlow());
+    }
+
+    /**
+     * start pre-analysis, the only API for pre-analysis.
+     * this method will block until pre-analysis finish.
+     *
+     * @param incremental
+     * @param context
+     * @return is incremental compile mode
+     * @throws IOException
+     * @throws InterruptedException
+     */
+    public boolean execute(boolean incremental, TransformContext context) throws IOException, InterruptedException {
+        Log.d(context.toString());
+        long duration = System.currentTimeMillis();
+
+        contextReader = new ContextReader(context);
+
+        if (incremental && context.isIncremental() && !cache.isHookClassModified(context)){
+            // can use incremental
+            partial = true;
+
+            saveData(partialParse(context), context);
+        } else {
+            // must full compile
+            partial = false;
+
+            // clear LocalCache and TransformContext
+            cache.clear();
+            context.clear();
+
+            saveData(fullyParse(context), context);
+
+            duration = System.currentTimeMillis() - duration;
+            Log.tag("Timer").i("pre parse cost: " + duration);
+        }
+        return partial;
+    }
+
+    private PreAnalysisClassFetcher partialParse(TransformContext context) throws IOException, InterruptedException {
+        PreAnalysisClassFetcher preAnalysisClassFetcher = new PreAnalysisClassFetcher();
+        // load cached full data into graph.
+        cache.accept(graph);
+        contextReader.accept(true, preAnalysisClassFetcher);
+        return preAnalysisClassFetcher;
+    }
+
+    private PreAnalysisClassFetcher fullyParse(TransformContext context) throws IOException, InterruptedException {
+        PreAnalysisClassFetcher preAnalysisClassFetcher = new PreAnalysisClassFetcher();
+        contextReader.accept(false, preAnalysisClassFetcher);
+        return preAnalysisClassFetcher;
+    }
+
+    private void saveData(PreAnalysisClassFetcher preAnalysisClassFetcher, TransformContext context) {
+        if (partial) {
+            cache.savePartially(graph.toLocalNodes());
+        } else {
+            cache.saveFully(graph.toLocalNodes(), preAnalysisClassFetcher.hookClasses, preAnalysisClassFetcher.hookClassesInDir, new ArrayList<>(preAnalysisClassFetcher.jarPathOfHookClasses));
+        }
+
+        context.setGraph(graph.generate());
+        context.setHookClasses(cache.hookClasses());
+    }
+
+
+    /**
+     * ClassFetcher to fetch all changed classed in this compilation.
+     */
+    private class PreAnalysisClassFetcher implements ClassFetcher {
+
+        List<String> hookClasses = new ArrayList<>(4);
+        List<String> hookClassesInDir = new ArrayList<>(4);
+        Set<String> jarPathOfHookClasses = new HashSet<>();
+
+        @Override
+        public boolean onStart(QualifiedContent content) {
+            return true;
+        }
+
+        @Override
+        public void onClassFetch(QualifiedContent content, Status status, String relativePath, byte[] bytes) {
+            if (relativePath.endsWith(".class")) {
+                PreClassProcessor.ProcessResult result = classProcessor.process(bytes);
+
+                // if this time is incremental, the hook class won't be fetched.
+                if (partial && result.isHookClass) {
+                    partial = false;
+                    throw new ParseFailureException(result.toString());
+                }
+
+                // store hook classes for next compile
+                if (result.isHookClass) {
+                    synchronized (this) {
+                        hookClasses.add(result.entity.name);
+                        if (content instanceof JarInput) {
+                            jarPathOfHookClasses.add(content.getFile().getAbsolutePath());
+                        } else {
+                            hookClassesInDir.add(Util.toSystemDependentFile(content.getFile(), relativePath).getAbsolutePath());
+                        }
+                    }
+                }
+
+                // update the graph
+                if (status != Status.REMOVED) {
+                    graph.add(result.entity, status);
+                } else {
+                    graph.remove(result.entity.name);
+                }
+            }
+        }
+
+        @Override
+        public void onComplete(QualifiedContent content) {
+        }
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/PreClassProcessor.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/PreClassProcessor.java
new file mode 100644
index 0000000..0b8d794
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/PreClassProcessor.java
@@ -0,0 +1,32 @@
+package me.ele.lancet.plugin.internal.preprocess;
+
+
+import me.ele.lancet.weaver.internal.graph.ClassEntity;
+
+/**
+ * Created by gengwanpeng on 17/4/27.
+ */
+public interface PreClassProcessor {
+
+    ProcessResult process(byte[] classBytes);
+
+    class ProcessResult {
+
+
+        public ProcessResult(boolean isHookClass, ClassEntity entity) {
+            this.isHookClass = isHookClass;
+            this.entity = entity;
+        }
+
+        public boolean isHookClass;
+        public ClassEntity entity;
+
+        @Override
+        public String toString() {
+            return "ProcessResult{" +
+                    "isHookClass=" + isHookClass +
+                    ", entity=" + entity +
+                    '}';
+        }
+    }
+}
diff --git a/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/PreProcessClassVisitor.java b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/PreProcessClassVisitor.java
new file mode 100644
index 0000000..6c6f65b
--- /dev/null
+++ b/lancet-plugin/src/main/java/me/ele/lancet/plugin/internal/preprocess/PreProcessClassVisitor.java
@@ -0,0 +1,65 @@
+package me.ele.lancet.plugin.internal.preprocess;
+
+import com.dieyidezui.lancet.rt.annotations.Insert;
+import com.dieyidezui.lancet.rt.annotations.Proxy;
+import com.dieyidezui.lancet.rt.annotations.TryCatchHandler;
+import me.ele.lancet.weaver.internal.graph.ClassEntity;
+import me.ele.lancet.weaver.internal.graph.FieldEntity;
+import me.ele.lancet.weaver.internal.graph.MethodEntity;
+import org.objectweb.asm.*;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+/**
+ * Created by gengwanpeng on 17/4/27.
+ */
+public class PreProcessClassVisitor extends ClassVisitor {
+
+    private static final String PROXY = Type.getDescriptor(Proxy.class);
+    private static final String INSERT = Type.getDescriptor(Insert.class);
+    private static final String TRY_CATCH = Type.getDescriptor(TryCatchHandler.class);
+
+    private boolean isHookClass;
+    private ClassEntity entity;
+
+    PreProcessClassVisitor(int api) {
+        super(api, null);
+    }
+
+    public PreClassProcessor.ProcessResult getProcessResult() {
+        return new PreClassProcessor.ProcessResult(isHookClass, entity);
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+        entity = new ClassEntity(access, name, superName, interfaces == null ? Collections.emptyList() : Arrays.asList(interfaces));
+    }
+
+    @Override
+    public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {
+        entity.fields.add(new FieldEntity(access, name, desc));
+        return null;
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+        entity.methods.add(new MethodEntity(access, name, desc));
+        if (!isHookClass) {
+            return new MethodVisitor(Opcodes.ASM5) {
+                @Override
+                public AnnotationVisitor visitAnnotation(String annoDesc, boolean visible) {
+                    judge(annoDesc);
+                    return null;
+                }
+            };
+        }
+        return null;
+    }
+
+    private void judge(String desc) {
+        if (!isHookClass && (INSERT.equals(desc) || PROXY.equals(desc) || TRY_CATCH.equals(desc))) {
+            isHookClass = true;
+        }
+    }
+}
diff --git a/lancet-plugin/src/main/resources/META-INF/gradle-plugins/me.ele.lancet.properties b/lancet-plugin/src/main/resources/META-INF/gradle-plugins/me.ele.lancet.properties
new file mode 100644
index 0000000..a1e14d4
--- /dev/null
+++ b/lancet-plugin/src/main/resources/META-INF/gradle-plugins/me.ele.lancet.properties
@@ -0,0 +1 @@
+implementation-class=me.ele.lancet.plugin.LancetPlugin
\ No newline at end of file
diff --git a/lancet-weaver/.gitignore b/lancet-weaver/.gitignore
new file mode 100644
index 0000000..796b96d
--- /dev/null
+++ b/lancet-weaver/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/lancet-weaver/build.gradle b/lancet-weaver/build.gradle
new file mode 100644
index 0000000..3697028
--- /dev/null
+++ b/lancet-weaver/build.gradle
@@ -0,0 +1,23 @@
+apply plugin: 'java'
+
+dependencies {
+    testCompile "junit:junit:4.12"
+    testCompile 'com.squareup.okio:okio:1.11.0'
+    testCompile 'org.assertj:assertj-core:3.6.2'
+
+    compileClasspath "com.android.tools.build:gradle:$android_tools_version"
+    compile "me.ele:lancet-base:1.0.4"
+    compile gradleApi()
+    compileClasspath "com.google.guava:guava:$guava_version"
+    compile "org.ow2.asm:asm:$asm_version"
+    compile 'org.ow2.asm:asm-tree:7.0'
+    compile 'org.ow2.asm:asm-util:7.0'
+    compile 'org.ow2.asm:asm-commons:7.0'
+    compile 'org.ow2.asm:asm-analysis:7.0'
+    compile 'org.ow2.asm:asm-test:7.0'
+}
+
+sourceCompatibility = "1.8"
+targetCompatibility = "1.8"
+
+
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/ClassData.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/ClassData.java
new file mode 100644
index 0000000..79ed2e0
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/ClassData.java
@@ -0,0 +1,31 @@
+package me.ele.lancet.weaver;
+
+/**
+ * Created by Jude on 2017/4/25.
+ */
+
+public class ClassData {
+    byte[] classBytes;
+    String className;
+
+    public ClassData(byte[] classBytes, String className) {
+        this.classBytes = classBytes;
+        this.className = className;
+    }
+
+    public byte[] getClassBytes() {
+        return classBytes;
+    }
+
+    public void setClassBytes(byte[] classBytes) {
+        this.classBytes = classBytes;
+    }
+
+    public String getClassName() {
+        return className;
+    }
+
+    public void setClassName(String className) {
+        this.className = className;
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/MetaParser.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/MetaParser.java
new file mode 100644
index 0000000..f5f39c1
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/MetaParser.java
@@ -0,0 +1,16 @@
+package me.ele.lancet.weaver;
+
+import java.util.List;
+
+import me.ele.lancet.weaver.internal.entity.TransformInfo;
+import me.ele.lancet.weaver.internal.graph.Graph;
+
+
+/**
+ *
+ * Created by gengwanpeng on 17/3/21.
+ */
+public interface MetaParser {
+
+    TransformInfo parse(List<String> classes, Graph graph);
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/Weaver.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/Weaver.java
new file mode 100644
index 0000000..dacb93a
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/Weaver.java
@@ -0,0 +1,18 @@
+package me.ele.lancet.weaver;
+
+/**
+ * Created by gengwanpeng on 17/3/21.
+ */
+public interface Weaver{
+
+    /**
+     * Transform input class with specified rules.
+     * Input one class may return two classes, because weaver may create multiple inner classes.
+     * this method will be invoke in multi-threaded and multi-process
+     *
+     * @param input the bytecode of the class want to transform.
+     * @param relativePath the file path of the class, end with .class, the new classes will output into the same path.
+     * @return the bytecode of transformed classes.
+     */
+    ClassData[] weave(byte[] input, String relativePath);
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/AsmWeaver.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/AsmWeaver.java
new file mode 100644
index 0000000..69409f6
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/AsmWeaver.java
@@ -0,0 +1,53 @@
+package me.ele.lancet.weaver.internal;
+
+import me.ele.lancet.weaver.ClassData;
+import me.ele.lancet.weaver.Weaver;
+import me.ele.lancet.weaver.internal.asm.ClassTransform;
+import me.ele.lancet.weaver.internal.entity.TransformInfo;
+import me.ele.lancet.weaver.internal.graph.Graph;
+import me.ele.lancet.weaver.internal.log.Log;
+
+
+/**
+ * Created by gengwanpeng on 17/3/21.
+ */
+public class AsmWeaver implements Weaver {
+
+    /**
+     * Create a AsmWeaver instance. In a compilation process, the AsmWeaver instance will only be created once.
+     *
+     * @param transformInfo the transformInfo for this compilation process.
+     * @param graph
+     * @return
+     */
+    public static Weaver newInstance(TransformInfo transformInfo, Graph graph) {
+        return new AsmWeaver(transformInfo, graph);
+    }
+
+    private final TransformInfo transformInfo;
+    private final Graph graph;
+
+    private AsmWeaver(TransformInfo transformInfo, Graph graph) {
+        Log.d(transformInfo.toString());
+        this.graph = graph;
+        this.transformInfo = transformInfo;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public ClassData[] weave(byte[] input, String relativePath) {
+        if(!relativePath.endsWith(".class")){
+            throw new IllegalArgumentException("relativePath is not a class: " + relativePath);
+        }
+        String internalName = relativePath.substring(0, relativePath.lastIndexOf('.'));
+        try {
+            return ClassTransform.weave(transformInfo, graph, input, internalName);
+        }catch (RuntimeException e){
+            Log.e("error in transform: " + relativePath, e);
+            return new ClassData[]{new ClassData(input, internalName)};
+        }
+    }
+
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/ClassCollector.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/ClassCollector.java
new file mode 100644
index 0000000..ac03d22
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/ClassCollector.java
@@ -0,0 +1,83 @@
+package me.ele.lancet.weaver.internal.asm;
+
+
+import me.ele.lancet.weaver.internal.graph.Graph;
+import org.objectweb.asm.*;
+import org.objectweb.asm.util.CheckClassAdapter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import me.ele.lancet.weaver.ClassData;
+
+/**
+ * Created by Jude on 2017/4/25.
+ */
+
+public class ClassCollector {
+
+    // canonical name
+    String originClassName;
+    ClassWriter originClassWriter;
+
+    ClassReader mClassReader;
+    Graph graph;
+
+    // simple name of innerClass
+    Map<String, ClassWriter> mClassWriters = new HashMap<>();
+
+    public ClassCollector(ClassReader mClassReader, Graph graph) {
+        this.mClassReader = mClassReader;
+        this.graph = graph;
+    }
+
+    void setOriginClassName(String originClassName) {
+        this.originClassName = originClassName;
+    }
+
+    public ClassVisitor getOriginClassVisitor() {
+        if(originClassWriter ==null){
+            originClassWriter = new ClassWriter(mClassReader, 0);
+        }
+        return originClassWriter;
+    }
+
+    public ClassVisitor getInnerClassVisitor(String classSimpleName) {
+        ClassWriter writer = mClassWriters.get(classSimpleName);
+        if (writer == null) {
+            writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+            initForWriter(writer, classSimpleName);
+            mClassWriters.put(classSimpleName, writer);
+        }
+        return writer;
+    }
+
+    private void initForWriter(ClassVisitor visitor, String classSimpleName) {
+        visitor.visit(Opcodes.V1_7, Opcodes.ACC_SUPER, getCanonicalName(classSimpleName), null, "java/lang/Object", null);
+        MethodVisitor mv = visitor.visitMethod(Opcodes.ACC_PRIVATE, "<init>", "()V", null, null);
+        mv.visitCode();
+        mv.visitVarInsn(Opcodes.ALOAD, 0);
+        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+        mv.visitInsn(Opcodes.RETURN);
+        mv.visitMaxs(1, 1);
+        mv.visitEnd();
+    }
+
+    public ClassData[] generateClassBytes() {
+        for (String className : mClassWriters.keySet()) {
+            originClassWriter.visitInnerClass(getCanonicalName(className), originClassName, className, Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC);
+        }
+        ClassData[] classDataArray = new ClassData[mClassWriters.size() + 1];
+        int index = 0;
+        for (Map.Entry<String, ClassWriter> entry : mClassWriters.entrySet()) {
+            classDataArray[index] = new ClassData(entry.getValue().toByteArray(), getCanonicalName(entry.getKey()));
+            index++;
+        }
+        classDataArray[index] = new ClassData(originClassWriter.toByteArray(), originClassName);
+        return classDataArray;
+    }
+
+    public String getCanonicalName(String simpleName) {
+        return originClassName + "$" + simpleName;
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/ClassContext.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/ClassContext.java
new file mode 100644
index 0000000..fd7f20f
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/ClassContext.java
@@ -0,0 +1,38 @@
+package me.ele.lancet.weaver.internal.asm;
+
+import me.ele.lancet.weaver.internal.graph.Graph;
+import org.objectweb.asm.ClassVisitor;
+
+import java.util.BitSet;
+
+/**
+ * Created by gengwanpeng on 17/5/12.
+ */
+public class ClassContext {
+
+    private final Graph graph;
+    private final MethodChain chain;
+    private final ClassVisitor tail;
+
+    public String name;
+    public String superName;
+
+    public ClassContext(Graph graph, MethodChain chain, ClassVisitor tail) {
+        this.graph = graph;
+        this.chain = chain;
+        this.tail = tail;
+    }
+
+    public ClassVisitor getTail() {
+        return tail;
+    }
+
+    public Graph getGraph() {
+        return graph;
+    }
+
+    public MethodChain getChain() {
+        return chain;
+    }
+
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/ClassTransform.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/ClassTransform.java
new file mode 100644
index 0000000..6c12929
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/ClassTransform.java
@@ -0,0 +1,63 @@
+package me.ele.lancet.weaver.internal.asm;
+
+import org.objectweb.asm.ClassReader;
+
+import me.ele.lancet.weaver.ClassData;
+import me.ele.lancet.weaver.internal.asm.classvisitor.HookClassVisitor;
+import me.ele.lancet.weaver.internal.asm.classvisitor.InsertClassVisitor;
+import me.ele.lancet.weaver.internal.asm.classvisitor.ProxyClassVisitor;
+import me.ele.lancet.weaver.internal.asm.classvisitor.TryCatchInfoClassVisitor;
+import me.ele.lancet.weaver.internal.entity.TransformInfo;
+import me.ele.lancet.weaver.internal.graph.Graph;
+
+/**
+ * Created by Jude on 2017/4/25.
+ */
+
+public class ClassTransform {
+
+    public static final String AID_INNER_CLASS_NAME = "_lancet";
+
+    public static ClassData[] weave(TransformInfo transformInfo, Graph graph, byte[] classByte, String internalName) {
+        ClassCollector classCollector = new ClassCollector(new ClassReader(classByte), graph);
+
+        classCollector.setOriginClassName(internalName);
+
+        MethodChain chain = new MethodChain(internalName, classCollector.getOriginClassVisitor(), graph);
+        ClassContext context = new ClassContext(graph, chain, classCollector.getOriginClassVisitor());
+
+        ClassTransform transform = new ClassTransform(classCollector, context);
+        transform.connect(new HookClassVisitor(transformInfo.hookClasses));
+        transform.connect(new ProxyClassVisitor(transformInfo.proxyInfo));
+        transform.connect(new InsertClassVisitor(transformInfo.executeInfo));
+        transform.connect(new TryCatchInfoClassVisitor(transformInfo.tryCatchInfo));
+        transform.startTransform();
+        return classCollector.generateClassBytes();
+    }
+
+    private LinkedClassVisitor mHeadVisitor;
+    private LinkedClassVisitor mTailVisitor;
+    private ClassCollector mClassCollector;
+    private final ClassContext context;
+
+    public ClassTransform(ClassCollector mClassCollector, ClassContext context) {
+        this.mClassCollector = mClassCollector;
+        this.context = context;
+    }
+
+    void connect(LinkedClassVisitor visitor) {
+        if (mHeadVisitor == null) {
+            mHeadVisitor = visitor;
+        } else {
+            mTailVisitor.setNextClassVisitor(visitor);
+        }
+        mTailVisitor = visitor;
+        visitor.setClassCollector(mClassCollector);
+        visitor.setContext(context);
+    }
+
+    void startTransform() {
+        mTailVisitor.setNextClassVisitor(mClassCollector.getOriginClassVisitor());
+        mClassCollector.mClassReader.accept(mHeadVisitor, 0);
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/LinkedClassVisitor.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/LinkedClassVisitor.java
new file mode 100644
index 0000000..55553f1
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/LinkedClassVisitor.java
@@ -0,0 +1,45 @@
+package me.ele.lancet.weaver.internal.asm;
+
+import me.ele.lancet.weaver.internal.graph.Graph;
+import me.ele.lancet.weaver.internal.util.Bitset;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+/**
+ * Created by Jude on 2017/4/25.
+ */
+
+public class LinkedClassVisitor extends ClassVisitor {
+
+
+    private ClassContext context;
+    private ClassCollector mClassCollector;
+
+
+    public LinkedClassVisitor() {
+        super(Opcodes.ASM5);
+    }
+
+    public void setContext(ClassContext context) {
+        this.context = context;
+    }
+
+    void setClassCollector(ClassCollector classCollector) {
+        this.mClassCollector = classCollector;
+    }
+
+    public ClassContext getContext() {
+        return context;
+    }
+
+    protected ClassCollector getClassCollector() {
+        return mClassCollector;
+    }
+
+    public void setNextClassVisitor(ClassVisitor classVisitor) {
+        cv = classVisitor;
+    }
+
+
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/MethodChain.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/MethodChain.java
new file mode 100644
index 0000000..d5c80c0
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/MethodChain.java
@@ -0,0 +1,296 @@
+package me.ele.lancet.weaver.internal.asm;
+
+import com.google.common.base.Preconditions;
+import com.dieyidezui.lancet.rt.annotations.ClassOf;
+import me.ele.lancet.weaver.internal.asm.classvisitor.methodvisitor.AutoUnboxMethodVisitor;
+import me.ele.lancet.weaver.internal.graph.ClassEntity;
+import me.ele.lancet.weaver.internal.graph.FieldEntity;
+import me.ele.lancet.weaver.internal.graph.Graph;
+import me.ele.lancet.weaver.internal.log.Log;
+import me.ele.lancet.weaver.internal.parser.AopMethodAdjuster;
+import me.ele.lancet.weaver.internal.util.Bitset;
+import me.ele.lancet.weaver.internal.util.PrimitiveUtil;
+import me.ele.lancet.weaver.internal.util.TypeUtil;
+import org.objectweb.asm.*;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+
+
+/**
+ * Created by gengwanpeng on 17/5/9.
+ */
+public class MethodChain {
+
+    private static final String ACCESS = "access$";
+    private static final String FORMAT = "access$%03d";
+    private static final String CLASS_OF = Type.getDescriptor(ClassOf.class);
+
+    private final String className;
+    private final ClassVisitor base;
+    private final Graph graph;
+    private Bitset bitset;
+
+    private Invoker head;
+
+    private Map<String, FieldEntity> fieldMap;
+    private Map<String, Invoker> invokerMap = new HashMap<>();
+
+
+    public MethodChain(String className, ClassVisitor base, Graph graph) {
+        this.className = className;
+        this.base = base;
+        this.graph = graph;
+        this.bitset = new Bitset();
+        this.bitset.setInitializer(b -> {
+            int len = ACCESS.length();
+            ClassEntity entity = graph.get(className).entity;
+            entity.methods.forEach(m -> {
+                if (TypeUtil.isStatic(m.access) && m.name.startsWith(ACCESS)) {
+                    bitset.tryAdd(m.name, len);
+                }
+            });
+        });
+    }
+
+    private void head(int access, int opcode, String owner, String name, String desc) {
+        this.head = Invoker.forMethod(
+                new MethodInsnNode(opcode, owner, name, desc, opcode == Opcodes.INVOKEINTERFACE)
+                , !hasPermission(access, owner), className);
+    }
+
+    private boolean hasPermission(int access, String owner) {
+        return TypeUtil.isPublic(access) || !TypeUtil.isPrivate(access) && owner.equals(className);
+    }
+
+    public void headFromProxy(int opcode, String owner, String name, String desc) {
+        int access = Opcodes.ACC_PRIVATE;
+        if (opcode == Opcodes.INVOKEINTERFACE || opcode == Opcodes.INVOKEVIRTUAL) {
+            access = Opcodes.ACC_PUBLIC;
+        }
+        head(access, opcode, owner, name, desc);
+    }
+
+    public void headFromInsert(int access, String owner, String name, String desc) {
+        head(access, TypeUtil.isStatic(access) ? Opcodes.INVOKESTATIC : Opcodes.INVOKESPECIAL, owner, name, desc);
+    }
+
+
+    public void next(String className, int access, String name, String desc, MethodNode node, ClassVisitor cv) {
+        String[] exs = (String[]) node.exceptions.toArray(new String[0]);
+        head.createIfNeed(base, bitset, exs);
+
+        MethodVisitor mv = cv.visitMethod(access, name, desc, null, exs);
+        node.accept(new MethodVisitor(Opcodes.ASM5, new AutoUnboxMethodVisitor(mv)) {
+
+            @Override
+            public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
+                if (opcode == AopMethodAdjuster.OP_CALL) {
+                    head.loadArgsAndInvoke(mv);
+                } else if (opcode == AopMethodAdjuster.OP_THIS_GET_FIELD) {
+                    dealField(Opcodes.GETFIELD, name, mv);
+                } else if (opcode == AopMethodAdjuster.OP_THIS_PUT_FIELD) {
+                    dealField(Opcodes.PUTFIELD, name, mv);
+                } else {
+                    super.visitMethodInsn(opcode, owner, name, desc, itf);
+                }
+            }
+
+            @Override
+            public AnnotationVisitor visitParameterAnnotation(int parameter, String desc, boolean visible) {
+                if (CLASS_OF.equals(desc)) {
+                    return null;
+                }
+                return super.visitParameterAnnotation(parameter, desc, visible);
+            }
+
+        });
+
+        headFromInsert(access, className, name, desc);
+    }
+
+    private void dealField(int opcode, String name, MethodVisitor mv) {
+        initFields();
+
+        // always store in object, auto box and unbox.
+        final String obj = "Ljava/lang/Object;";
+
+        FieldEntity entity = fieldMap.get(name);
+        if (entity == null) {
+            base.visitField(Opcodes.ACC_PRIVATE, name, obj, null, null);
+            fieldMap.put(name, entity = new FieldEntity(Opcodes.ACC_PRIVATE, name, obj));
+        }
+
+        boolean needCreate = TypeUtil.isPrivate(entity.access);
+        String desc = entity.desc;
+
+        invokerMap.computeIfAbsent(opcode + " " + name,
+                k -> {
+                    Invoker invoker = Invoker.forField(new FieldInsnNode(opcode, className, name, desc), needCreate, className);
+                    invoker.createIfNeed(base, bitset, null);
+                    return invoker;
+                })
+                .loadArgsAndInvoke(mv);
+
+    }
+
+    private void initFields() {
+        if (fieldMap == null) {
+            this.fieldMap = graph.get(className).entity.fields.stream()
+                    .collect(Collectors.toMap(f -> f.name, f -> f));
+        }
+    }
+
+    public void fakePreMethod(String className, int access, String name, String desc, String signature, String[] exceptions) {
+        MethodVisitor mv = base.visitMethod(access, name, desc, null, exceptions);
+
+        createMethod(access, desc, head.action()).accept(mv);
+
+        headFromInsert(access, className, name, desc);
+    }
+
+    public Invoker getHead(){
+        return head;
+    }
+
+    public void visitHead(MethodVisitor mv) {
+        head.invoke(mv);
+    }
+
+    public static class Invoker implements Opcodes {
+
+        public static Invoker forField(FieldInsnNode fn, boolean needCreate, String className) {
+            String staticDesc = staticDesc(className, null, Preconditions.checkNotNull(fn));
+            return new Invoker(null, fn, needCreate, staticDesc, className);
+        }
+
+        public static Invoker forMethod(MethodInsnNode mn, boolean needCreate, String className) {
+            String staticDesc = staticDesc(mn.owner, Preconditions.checkNotNull(mn), null);
+            return new Invoker(mn, null, needCreate, staticDesc, className);
+        }
+
+        private static String staticDesc(String className, MethodInsnNode mn, FieldInsnNode fn) {
+            String desc = mn != null ?
+                    mn.desc :
+                    (fn.getOpcode() == PUTFIELD ?
+                            '(' + fn.desc + ")V" : "()" + fn.desc);
+            int access = mn != null && mn.getOpcode() == INVOKESTATIC ? ACC_STATIC : 0;
+            return TypeUtil.descToStatic(access, desc, className);
+        }
+
+        final MethodInsnNode mn;
+        final FieldInsnNode fn;
+
+        final String staticDesc;
+        final String owner;
+        final boolean needCreate;
+
+        MethodInsnNode syntheticNode;
+
+        Invoker(MethodInsnNode mn, FieldInsnNode fn, boolean needCreate, String staticDesc, String owner) {
+            this.mn = mn;
+            this.fn = fn;
+            this.needCreate = needCreate;
+            this.staticDesc = staticDesc;
+            this.owner = owner;
+        }
+
+        public void createIfNeed(ClassVisitor cv, Bitset bitset, String[] exceptions) {
+            if (syntheticNode != null) {
+                throw new IllegalStateException("can't create more than once");
+            }
+            if (needCreate) {
+                String name = String.format(FORMAT, bitset.consume());
+
+                syntheticNode = new MethodInsnNode(INVOKESTATIC, owner, name, staticDesc, false);
+                Log.tag("transform").i("create synthetic node :" + owner + " " + name + " " + staticDesc);
+
+                MethodVisitor mv = cv.visitMethod(ACC_STATIC | ACC_SYNTHETIC, name, staticDesc, null, exceptions);
+
+                createMethod(ACC_STATIC, staticDesc, mn == null ? fn : mn)
+                        .accept(mv);
+            }
+        }
+
+        public void invoke(MethodVisitor mv) {
+            action().accept(mv);
+        }
+
+        public void loadArgsAndInvoke(MethodVisitor mv) {
+            //load args
+            if (mn != null) {
+                Type[] params = Type.getArgumentTypes(staticDesc);
+                int index = 0;
+                for (Type t : params) {
+                    mv.visitVarInsn(t.getOpcode(ILOAD), index);
+                    index += t.getSize();
+                }
+                invoke(mv);
+            } else {
+                if (fn.getOpcode() == PUTFIELD) { // unbox
+                    mv.visitVarInsn(ALOAD, 0);
+                    mv.visitInsn(SWAP);
+                    if (PrimitiveUtil.isPrimitive(fn.desc)) {
+                        String owner = PrimitiveUtil.box(fn.desc);
+                        mv.visitMethodInsn(INVOKEVIRTUAL, PrimitiveUtil.virtualType(owner),
+                                PrimitiveUtil.unboxMethod(owner), "()" + fn.desc, false);
+                    }
+                    invoke(mv);
+                } else { // box
+                    mv.visitVarInsn(ALOAD, 0);
+                    invoke(mv);
+                    if (PrimitiveUtil.isPrimitive(fn.desc)) {
+                        String owner = PrimitiveUtil.box(fn.desc);
+                        mv.visitMethodInsn(INVOKESTATIC, owner,
+                                "valueOf", "(" + fn.desc + ")L" + owner + ";", false);
+                        ((AutoUnboxMethodVisitor) mv).markBoxed();
+                    }
+                }
+            }
+        }
+
+        public AbstractInsnNode action() {
+            if (syntheticNode != null) {
+                return syntheticNode;
+            } else if (mn != null) {
+                return mn;
+            } else {
+                return fn;
+            }
+        }
+    }
+
+    private static Consumer<MethodVisitor> createMethod(int access, String desc, AbstractInsnNode action) {
+        return mv -> {
+            mv.visitCode();
+
+            //load args
+            Type[] params = Type.getArgumentTypes(desc);
+            int index = 0;
+            if (!TypeUtil.isStatic(access)) {
+                index++;
+                mv.visitVarInsn(Opcodes.ALOAD, 0);
+            }
+
+            for (Type t : params) {
+                mv.visitVarInsn(t.getOpcode(Opcodes.ILOAD), index);
+                index += t.getSize();
+            }
+            // action
+            action.accept(mv);
+
+            // ret
+            Type ret = Type.getReturnType(desc);
+            mv.visitInsn(ret.getOpcode(Opcodes.IRETURN));
+
+            mv.visitMaxs(Math.max(index, ret.getSize()), index);
+            mv.visitEnd();
+        };
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/HookClassVisitor.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/HookClassVisitor.java
new file mode 100644
index 0000000..209ce2a
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/HookClassVisitor.java
@@ -0,0 +1,42 @@
+package me.ele.lancet.weaver.internal.asm.classvisitor;
+
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.util.Set;
+
+import me.ele.lancet.weaver.internal.asm.LinkedClassVisitor;
+import me.ele.lancet.weaver.internal.util.TypeUtil;
+
+/**
+ * Created by gengwanpeng on 17/5/15.
+ */
+public class HookClassVisitor extends LinkedClassVisitor {
+
+    private final Set<String> excludes;
+    private boolean matched;
+
+    public HookClassVisitor(Set<String> excludes) {
+        this.excludes = excludes;
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+        getContext().name = name;
+        getContext().superName = superName;
+        if (excludes.contains(name)) {
+            matched = true;
+            this.cv = getContext().getTail(); // make delegate point to the tail, ignore middle transform
+        }
+        super.visit(version, access, name, signature, superName, interfaces);
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+        if (matched){
+            return super.visitMethod(TypeUtil.resetAccessScope(access,Opcodes.ACC_PUBLIC), name, desc, signature, exceptions);
+        }else {
+            return super.visitMethod(access, name, desc, signature, exceptions);
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/InsertClassVisitor.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/InsertClassVisitor.java
new file mode 100644
index 0000000..ac6f095
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/InsertClassVisitor.java
@@ -0,0 +1,102 @@
+package me.ele.lancet.weaver.internal.asm.classvisitor;
+
+import me.ele.lancet.weaver.internal.asm.MethodChain;
+import org.objectweb.asm.*;
+import org.objectweb.asm.commons.GeneratorAdapter;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import me.ele.lancet.weaver.internal.asm.ClassTransform;
+import me.ele.lancet.weaver.internal.asm.LinkedClassVisitor;
+import me.ele.lancet.weaver.internal.entity.InsertInfo;
+import me.ele.lancet.weaver.internal.log.Log;
+import me.ele.lancet.weaver.internal.util.TypeUtil;
+
+/**
+ * Created by gengwanpeng on 17/3/27.
+ */
+public class InsertClassVisitor extends LinkedClassVisitor {
+
+    private Map<String, List<InsertInfo>> executeInfos;
+    private List<InsertInfo> matched;
+
+
+    public InsertClassVisitor(Map<String, List<InsertInfo>> executeInfos) {
+        this.executeInfos = executeInfos;
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+        super.visit(version, access, name, signature, superName, interfaces);
+        matched = executeInfos.get(getContext().name);
+    }
+
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+        if (matched != null) {
+            List<InsertInfo> methodsMatched = new ArrayList<>(matched.size() >> 1);
+            matched.removeIf(e -> {
+                if (e.targetMethod.equals(name) && e.targetDesc.equals(desc)) {
+                    if (((e.sourceMethod.access ^ access) & Opcodes.ACC_STATIC) != 0) {
+                        throw new IllegalStateException(e.sourceClass + "." + e.sourceMethod.name + " should have the same static flag with "
+                                + getContext().name + "." + name);
+                    }
+                    methodsMatched.add(e);
+                    return true;
+                }
+                return false;
+            });
+
+            if (methodsMatched.size() > 0 && (access & (Opcodes.ACC_NATIVE | Opcodes.ACC_ABSTRACT)) == 0) {
+                Log.tag("transform").i("visit Insert method: " + getContext().name + "." + name + " " + desc);
+
+                String staticDesc = TypeUtil.descToStatic(access, desc, getContext().name);
+                ClassVisitor cv = getClassCollector().getInnerClassVisitor(ClassTransform.AID_INNER_CLASS_NAME);
+                String owner = getClassCollector().getCanonicalName(ClassTransform.AID_INNER_CLASS_NAME);
+                String newName = name + "$___twin___";
+                int newAccess = (access & ~(Opcodes.ACC_PROTECTED | Opcodes.ACC_PUBLIC)) | Opcodes.ACC_PRIVATE;
+
+                MethodChain chain = getContext().getChain();
+                chain.headFromInsert(newAccess, getContext().name, newName, desc);
+
+                methodsMatched.forEach(e -> {
+                    Log.tag("transform").i(
+                            " from " + e.sourceClass + "." + e.sourceMethod.name);
+                    String methodName = e.sourceClass.replace("/", "_") + "_" + e.sourceMethod.name;
+                    chain.next(owner, Opcodes.ACC_STATIC, methodName, staticDesc, e.threadLocalNode(), cv);
+                });
+                chain.fakePreMethod(getContext().name, access, name, desc, signature, exceptions);
+
+                return super.visitMethod(newAccess, newName, desc, signature, exceptions);
+            }
+        }
+        return super.visitMethod(access, name, desc, signature, exceptions);
+    }
+
+    @Override
+    public void visitEnd() {
+        if (matched != null && matched.size() > 0) {
+            new ArrayList<>(matched).stream()
+                    .collect(Collectors.groupingBy(e -> e.targetMethod)).forEach((k, v) -> {
+                if (v.stream().anyMatch(e -> e.createSuper)) {
+                    InsertInfo e = v.get(0);
+                    MethodVisitor mv = visitMethod(e.sourceMethod.access, e.targetMethod, e.targetDesc, e.sourceMethod.signature,
+                            (String[]) e.sourceMethod.exceptions.toArray(new String[0]));
+                    GeneratorAdapter adapter = new GeneratorAdapter(mv, e.sourceMethod.access, e.targetMethod, e.targetDesc);
+                    adapter.visitCode();
+                    adapter.loadThis();
+                    adapter.loadArgs();
+                    adapter.visitMethodInsn(Opcodes.INVOKESPECIAL, getContext().superName, e.targetMethod, e.targetDesc, false);
+                    adapter.returnValue();
+                    int sz = Type.getArgumentsAndReturnSizes(e.targetDesc);
+                    adapter.visitMaxs(Math.max(sz >> 2, sz & 3), sz >> 2);
+                    adapter.visitEnd();
+                }
+            });
+
+        }
+        super.visitEnd();
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/ProxyClassVisitor.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/ProxyClassVisitor.java
new file mode 100644
index 0000000..d44a44c
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/ProxyClassVisitor.java
@@ -0,0 +1,44 @@
+package me.ele.lancet.weaver.internal.asm.classvisitor;
+
+import me.ele.lancet.weaver.internal.asm.MethodChain;
+import org.objectweb.asm.MethodVisitor;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import me.ele.lancet.weaver.internal.asm.LinkedClassVisitor;
+import me.ele.lancet.weaver.internal.asm.classvisitor.methodvisitor.ProxyMethodVisitor;
+import me.ele.lancet.weaver.internal.entity.ProxyInfo;
+
+/**
+ * Created by Jude on 17/4/26.
+ */
+public class ProxyClassVisitor extends LinkedClassVisitor {
+
+    private List<ProxyInfo> infos;
+    private Map<String, List<ProxyInfo>> matches;
+    private Map<String, MethodChain.Invoker> maps = new HashMap<>();
+    public ProxyClassVisitor(List<ProxyInfo> infos) {
+        this.infos = infos;
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+        matches = infos.stream()
+                .filter(t -> t.match(name))
+                .collect(Collectors.groupingBy(t -> t.targetClass + " " + t.targetMethod + " " + t.targetDesc));
+
+        super.visit(version, access, name, signature, superName, interfaces);
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+        MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
+        if (matches.size() > 0) {
+            mv = new ProxyMethodVisitor(getContext().getChain(), mv, maps, matches, getContext().name, name, getClassCollector());
+        }
+        return mv;
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/TryCatchInfoClassVisitor.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/TryCatchInfoClassVisitor.java
new file mode 100644
index 0000000..9c51a39
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/TryCatchInfoClassVisitor.java
@@ -0,0 +1,47 @@
+package me.ele.lancet.weaver.internal.asm.classvisitor;
+
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import me.ele.lancet.weaver.internal.asm.LinkedClassVisitor;
+import me.ele.lancet.weaver.internal.asm.classvisitor.methodvisitor.TryCatchMethodVisitor;
+import me.ele.lancet.weaver.internal.entity.TryCatchInfo;
+import me.ele.lancet.weaver.internal.log.Log;
+
+
+/**
+ * Created by gengwanpeng on 17/3/27.
+ */
+public class TryCatchInfoClassVisitor extends LinkedClassVisitor {
+
+    private String className;
+    private List<TryCatchInfo> infos;
+    private List<TryCatchInfo> matches = null;
+
+
+    public TryCatchInfoClassVisitor(List<TryCatchInfo> infos) {
+        this.infos = infos;
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
+        className = name;
+        if (infos != null){
+            matches = infos.stream().filter(t -> t.match(name)).collect(Collectors.toList());
+        }
+        super.visit(version, access, name, signature, superName, interfaces);
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
+        MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
+        if (matches != null && matches.size() > 0) {
+            Log.tag("transform").i("visit TryCatch method: "+className+"."+name+" "+desc);
+            mv = new TryCatchMethodVisitor(Opcodes.ASM5, mv, matches);
+        }
+        return mv;
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/methodvisitor/AutoUnboxMethodVisitor.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/methodvisitor/AutoUnboxMethodVisitor.java
new file mode 100644
index 0000000..d7f60fa
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/methodvisitor/AutoUnboxMethodVisitor.java
@@ -0,0 +1,128 @@
+package me.ele.lancet.weaver.internal.asm.classvisitor.methodvisitor;
+
+
+import me.ele.lancet.weaver.internal.util.PrimitiveUtil;
+import org.objectweb.asm.*;
+
+/**
+ * Created by gengwanpeng on 17/5/31.
+ */
+public class AutoUnboxMethodVisitor extends MethodVisitor {
+
+    private boolean flag = false;
+    private String lastOwner;
+
+    public AutoUnboxMethodVisitor(MethodVisitor methodVisitor) {
+        super(Opcodes.ASM5, methodVisitor);
+    }
+
+    public void markBoxed() {
+        flag = true;
+    }
+
+    @Override
+    public void visitInsn(int opcode) {
+        clearFlag();
+        super.visitInsn(opcode);
+    }
+
+    private void clearFlag() {
+        flag = false;
+    }
+
+    @Override
+    public void visitIntInsn(int opcode, int operand) {
+        clearFlag();
+        super.visitIntInsn(opcode, operand);
+    }
+
+    @Override
+    public void visitVarInsn(int opcode, int var) {
+        clearFlag();
+        super.visitVarInsn(opcode, var);
+    }
+
+    @Override
+    public void visitTypeInsn(int opcode, String type) {
+        if (flag) {
+            if (opcode == Opcodes.CHECKCAST && !type.equals(lastOwner) && PrimitiveUtil.boxedNumberTypes().contains(type)) {
+                if (lastOwner == null || !PrimitiveUtil.boxedNumberTypes().contains(lastOwner)) {
+                    throw new IllegalStateException("can't cast bool or char to number");
+                }
+                String method = PrimitiveUtil.unboxMethod(type);
+                String primitive = PrimitiveUtil.unbox(type);
+                super.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Number", method, "()" + primitive, false);
+                super.visitMethodInsn(Opcodes.INVOKESTATIC, type, "valueOf", "(" + primitive + ")L" + type + ";", false);
+            }
+        }
+        clearFlag();
+        super.visitTypeInsn(opcode, type);
+    }
+
+    @Override
+    public void visitFieldInsn(int opcode, String owner, String name, String desc) {
+        clearFlag();
+        super.visitFieldInsn(opcode, owner, name, desc);
+    }
+
+    @Override
+    public void visitMethodInsn(int opcode, String owner, String name, String desc) {
+        clearFlag();
+        super.visitMethodInsn(opcode, owner, name, desc);
+    }
+
+    @Override
+    public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
+        this.lastOwner = owner;
+        clearFlag();
+        super.visitMethodInsn(opcode, owner, name, desc, itf);
+    }
+
+    @Override
+    public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs) {
+        clearFlag();
+        super.visitInvokeDynamicInsn(name, desc, bsm, bsmArgs);
+    }
+
+    @Override
+    public void visitJumpInsn(int opcode, Label label) {
+        clearFlag();
+        super.visitJumpInsn(opcode, label);
+    }
+
+    @Override
+    public void visitLdcInsn(Object cst) {
+        clearFlag();
+        super.visitLdcInsn(cst);
+    }
+
+    @Override
+    public void visitIincInsn(int var, int increment) {
+        clearFlag();
+        super.visitIincInsn(var, increment);
+    }
+
+    @Override
+    public void visitTableSwitchInsn(int min, int max, Label dflt, Label... labels) {
+        clearFlag();
+        super.visitTableSwitchInsn(min, max, dflt, labels);
+    }
+
+    @Override
+    public void visitLookupSwitchInsn(Label dflt, int[] keys, Label[] labels) {
+        clearFlag();
+        super.visitLookupSwitchInsn(dflt, keys, labels);
+    }
+
+    @Override
+    public void visitMultiANewArrayInsn(String desc, int dims) {
+        clearFlag();
+        super.visitMultiANewArrayInsn(desc, dims);
+    }
+
+    @Override
+    public void visitEnd() {
+        clearFlag();
+        super.visitEnd();
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/methodvisitor/ProxyMethodVisitor.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/methodvisitor/ProxyMethodVisitor.java
new file mode 100644
index 0000000..d64e4b7
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/methodvisitor/ProxyMethodVisitor.java
@@ -0,0 +1,76 @@
+package me.ele.lancet.weaver.internal.asm.classvisitor.methodvisitor;
+
+import me.ele.lancet.weaver.internal.asm.MethodChain;
+import me.ele.lancet.weaver.internal.util.TypeUtil;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.util.List;
+import java.util.Map;
+
+import me.ele.lancet.weaver.internal.asm.ClassCollector;
+import me.ele.lancet.weaver.internal.asm.ClassTransform;
+import me.ele.lancet.weaver.internal.entity.ProxyInfo;
+import me.ele.lancet.weaver.internal.log.Log;
+
+/**
+ * Created by Jude on 17/4/26.
+ */
+public class ProxyMethodVisitor extends MethodVisitor {
+
+    private final Map<String, MethodChain.Invoker> invokerMap;
+    private final Map<String, List<ProxyInfo>> matchMap;
+    private final String className;
+    private final String name;
+    private final ClassCollector classCollector;
+    private final MethodChain chain;
+
+    public ProxyMethodVisitor(MethodChain chain, MethodVisitor mv, Map<String, MethodChain.Invoker> invokerMap, Map<String, List<ProxyInfo>> matchMap, String className, String name, ClassCollector classCollector) {
+        super(Opcodes.ASM5, mv);
+        this.chain = chain;
+        this.invokerMap = invokerMap;
+        this.matchMap = matchMap;
+        this.className = className;
+        this.name = name;
+        this.classCollector = classCollector;
+    }
+
+    @Override
+    public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
+        String key = owner + " " + name + " " + desc;
+        List<ProxyInfo> infos = matchMap.get(key);
+        MethodChain.Invoker invoker = invokerMap.get(key);
+        if (invoker != null) {
+            invoker.invoke(mv);
+        } else if (infos != null && infos.size() > 0) {
+
+            String staticDesc = TypeUtil.descToStatic(opcode == Opcodes.INVOKESTATIC ? Opcodes.ACC_STATIC : 0, desc, owner);
+            // begin hook this code.
+            chain.headFromProxy(opcode, owner, name, desc);
+
+            String artificialClassname = classCollector.getCanonicalName(ClassTransform.AID_INNER_CLASS_NAME);
+            ClassVisitor cv = classCollector.getInnerClassVisitor(ClassTransform.AID_INNER_CLASS_NAME);
+
+            Log.tag("transform").i("start weave Call method " + " for " + owner + "." + name + desc +
+                    " in " + className + "." + this.name);
+
+            infos.forEach(c -> {
+                if (TypeUtil.isStatic(c.sourceMethod.access) != (opcode == Opcodes.INVOKESTATIC)) {
+                    throw new IllegalStateException(c.sourceClass + "." + c.sourceMethod.name + " should have the same " +
+                            "static flag with " + owner + "." + name);
+                }
+                Log.tag("transform").i(
+                        " from " + c.sourceClass + "." + c.sourceMethod.name);
+
+                String methodName = c.sourceClass.replace("/", "_") + "_" + c.sourceMethod.name;
+                chain.next(artificialClassname, Opcodes.ACC_STATIC, methodName, staticDesc, c.threadLocalNode(), cv);
+            });
+
+            invokerMap.put(key, chain.getHead());
+            chain.getHead().invoke(mv);
+        } else {
+            super.visitMethodInsn(opcode, owner, name, desc, itf);
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/methodvisitor/TryCatchMethodVisitor.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/methodvisitor/TryCatchMethodVisitor.java
new file mode 100644
index 0000000..71a1641
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/asm/classvisitor/methodvisitor/TryCatchMethodVisitor.java
@@ -0,0 +1,42 @@
+package me.ele.lancet.weaver.internal.asm.classvisitor.methodvisitor;
+
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import me.ele.lancet.weaver.internal.entity.TryCatchInfo;
+
+
+/**
+ * Created by gengwanpeng on 17/3/31.
+ */
+public class TryCatchMethodVisitor extends MethodVisitor {
+
+    private Set<Label> handlers = new HashSet<>();
+    private final List<TryCatchInfo> matches;
+
+    public TryCatchMethodVisitor(int api, MethodVisitor mv, List<TryCatchInfo> matches) {
+        super(api, mv);
+        this.matches = matches;
+    }
+
+    @Override
+    public void visitTryCatchBlock(Label start, Label end, Label handler, String type) {
+        handlers.add(handler);
+        super.visitTryCatchBlock(start, end, handler, type);
+    }
+
+    @Override
+    public void visitLabel(Label label) {
+        super.visitLabel(label);
+        if (label != null && handlers.contains(label)) {
+            for (TryCatchInfo info : matches) {
+                mv.visitMethodInsn(Opcodes.INVOKESTATIC, info.myClass, info.myMethod, info.methodDescriptor, false);
+            }
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/entity/InsertInfo.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/entity/InsertInfo.java
new file mode 100644
index 0000000..1121f5d
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/entity/InsertInfo.java
@@ -0,0 +1,49 @@
+package me.ele.lancet.weaver.internal.entity;
+
+import me.ele.lancet.weaver.internal.util.AsmUtil;
+import org.objectweb.asm.tree.MethodNode;
+
+/**
+ * Created by gengwanpeng on 17/3/27.
+ */
+public class InsertInfo {
+
+    public boolean createSuper;
+    public String targetClass;
+    public String targetMethod;
+    public String targetDesc;
+    public String sourceClass;
+    public MethodNode sourceMethod;
+
+    private ThreadLocal<MethodNode> local = new ThreadLocal<MethodNode>(){
+        @Override
+        synchronized protected MethodNode initialValue() {
+            return AsmUtil.clone(sourceMethod);
+        }
+    };
+
+    public InsertInfo(boolean createSuper, String targetClass, String targetMethod, String targetDesc, String sourceClass, MethodNode sourceMethod) {
+        this.createSuper = createSuper;
+        this.targetClass = targetClass;
+        this.targetMethod = targetMethod;
+        this.targetDesc = targetDesc;
+        this.sourceClass = sourceClass;
+        this.sourceMethod = sourceMethod;
+    }
+
+    public MethodNode threadLocalNode() {
+        return local.get();
+    }
+
+    @Override
+    public String toString() {
+        return "InsertInfo{" +
+                "createSuper=" + createSuper +
+                ", targetClass='" + targetClass + '\'' +
+                ", targetMethod='" + targetMethod + '\'' +
+                ", targetDesc='" + targetDesc + '\'' +
+                ", sourceClass='" + sourceClass + '\'' +
+                ", sourceMethod=" + sourceMethod +
+                '}';
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/entity/ProxyInfo.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/entity/ProxyInfo.java
new file mode 100644
index 0000000..807f252
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/entity/ProxyInfo.java
@@ -0,0 +1,69 @@
+package me.ele.lancet.weaver.internal.entity;
+
+import com.google.common.base.Strings;
+
+import me.ele.lancet.weaver.internal.util.AsmUtil;
+import org.objectweb.asm.tree.MethodNode;
+
+import java.util.regex.Pattern;
+
+
+/**
+ * Created by gengwanpeng on 17/3/27.
+ */
+public class ProxyInfo {
+
+    public String regex;
+    public String targetClass;
+    public String targetMethod;
+    public String targetDesc;
+    public String sourceClass;
+    public MethodNode sourceMethod;
+
+    public Pattern pattern;
+
+    private ThreadLocal<MethodNode> local = new ThreadLocal<MethodNode>(){
+        @Override
+        synchronized protected MethodNode initialValue() {
+            return AsmUtil.clone(sourceMethod);
+        }
+    };
+
+    public ProxyInfo(String regex, String targetClass, String targetMethod, String targetDesc, String sourceClass, MethodNode sourceMethod) {
+        this.regex = regex;
+        this.targetClass = targetClass;
+        this.targetMethod = targetMethod;
+        this.targetDesc = targetDesc;
+        this.sourceClass = sourceClass;
+        this.sourceMethod = sourceMethod;
+
+        if (!Strings.isNullOrEmpty(regex)) {
+            this.pattern = Pattern.compile(regex);
+        }
+    }
+
+    public MethodNode threadLocalNode() {
+        return local.get();
+    }
+
+    public boolean match(String className) {
+        return pattern == null || pattern.matcher(className).matches();
+    }
+
+
+    @Override
+    public String toString() {
+        return "ProxyInfo{" +
+                "  regex=" + regex +
+                ", targetClass='" + targetClass + '\'' +
+                ", targetMethod='" + targetMethod + '\'' +
+                ", targetDesc='" + targetDesc + '\'' +
+                ", sourceMethod.name=" + sourceMethod.name +
+                ", sourceMethod.desc=" + sourceMethod.desc +
+                ", sourceMethod.signature=" + sourceMethod.signature +
+                ", sourceMethod.access=" + sourceMethod.access +
+                ", sourceMethod.codeSize=" + sourceMethod.instructions.size() +
+                '}';
+    }
+
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/entity/TransformInfo.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/entity/TransformInfo.java
new file mode 100644
index 0000000..92203ce
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/entity/TransformInfo.java
@@ -0,0 +1,97 @@
+package me.ele.lancet.weaver.internal.entity;
+
+
+import java.util.*;
+
+/**
+ * Created by gengwanpeng on 17/3/27.
+ *
+ * A data sets store all data for transform operation.
+ *
+ */
+public class TransformInfo {
+
+    /**
+     * Key for target class's name.
+     * Value for all InsertInfo want insert into the target class.
+     */
+    public Map<String, List<InsertInfo>> executeInfo = new HashMap<>();
+    public List<ProxyInfo> proxyInfo = new ArrayList<>();
+    public List<TryCatchInfo> tryCatchInfo = new ArrayList<>();
+    public Set<String> hookClasses = new HashSet<>();
+
+    public TransformInfo(List<String> hookClasses) {
+        this.hookClasses.addAll(hookClasses);
+    }
+
+    public void combine(TransformInfo other) {
+        other.executeInfo.forEach((key, value) -> executeInfo.computeIfAbsent(key, k -> new LinkedList<>())
+                .addAll(value));
+
+        tryCatchInfo.addAll(other.tryCatchInfo);
+        proxyInfo.addAll(other.proxyInfo);
+        hookClasses.addAll(other.hookClasses);
+    }
+
+    public void addInsertInfo(InsertInfo e) {
+        executeInfo.computeIfAbsent(e.targetClass, k -> new LinkedList<>())
+                .add(e);
+    }
+
+    public void addProxyInfo(ProxyInfo c) {
+        proxyInfo.add(c);
+    }
+
+    public void addTryCatch(TryCatchInfo t) {
+        tryCatchInfo.add(t);
+    }
+
+    public void setInsertInfo(Map<String, List<InsertInfo>> executeInfo) {
+        this.executeInfo = executeInfo;
+    }
+
+    public void setTryCatchInfo(List<TryCatchInfo> tryCatchInfo) {
+        this.tryCatchInfo = tryCatchInfo;
+    }
+
+    public void setProxyInfo(List<ProxyInfo> proxyInfo) {
+        this.proxyInfo = proxyInfo;
+    }
+
+    public void setHookClasses(Set<String> hookClasses) {
+        this.hookClasses = hookClasses;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder content = new StringBuilder();
+        if (executeInfo != null) {
+            content.append("\nInsert:\n");
+            for (Map.Entry<String, List<InsertInfo>> executeList : executeInfo.entrySet()) {
+                content.append(' ').append(executeList.getKey()).append(":\n");
+                executeList.getValue().forEach(e -> {
+                    content.append("  ").append(e).append("\n");
+                });
+            }
+        }
+        if (proxyInfo != null) {
+            content.append("Proxy:\n");
+            for (ProxyInfo proxyInfo : this.proxyInfo) {
+                content.append(' ').append(proxyInfo).append("\n");
+            }
+        }
+        if (tryCatchInfo != null) {
+            content.append("TryCatch:\n");
+            for (TryCatchInfo tryCatchInfo : this.tryCatchInfo) {
+                content.append(' ').append(tryCatchInfo).append("\n");
+            }
+        }
+        if (hookClasses != null) {
+            content.append("HookClasses:\n");
+            for (String hookClasses : this.hookClasses) {
+                content.append(' ').append(hookClasses).append("\n");
+            }
+        }
+        return content.toString();
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/entity/TryCatchInfo.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/entity/TryCatchInfo.java
new file mode 100644
index 0000000..8d80b15
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/entity/TryCatchInfo.java
@@ -0,0 +1,44 @@
+package me.ele.lancet.weaver.internal.entity;
+
+import com.google.common.base.Strings;
+
+import java.util.regex.Pattern;
+
+/**
+ * Created by gengwanpeng on 17/3/27.
+ */
+public class TryCatchInfo {
+
+    public String regex;
+    public String myClass;
+    public String myMethod;
+    public String methodDescriptor;
+
+    private Pattern pattern;
+
+    public TryCatchInfo(String regex, String myClass, String myMethod, String methodDescriptor) {
+        this.regex = regex;
+        this.myClass = myClass;
+        this.myMethod = myMethod;
+        this.methodDescriptor = methodDescriptor;
+
+        if (!Strings.isNullOrEmpty(regex)) {
+            this.pattern = Pattern.compile(regex);
+        }
+    }
+
+    public boolean match(String className) {
+        return pattern == null || pattern.matcher(className).matches();
+    }
+
+    @Override
+    public String toString() {
+        return "TryCatchInfo{" +
+                "regex='" + regex + '\'' +
+                ", myClass='" + myClass + '\'' +
+                ", myMethod='" + myMethod + '\'' +
+                ", methodDescriptor='" + methodDescriptor + '\'' +
+                ", pattern=" + pattern +
+                '}';
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/exception/IllegalAnnotationException.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/exception/IllegalAnnotationException.java
new file mode 100644
index 0000000..afe924d
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/exception/IllegalAnnotationException.java
@@ -0,0 +1,22 @@
+package me.ele.lancet.weaver.internal.exception;
+
+/**
+ * Created by gengwanpeng on 17/5/3.
+ */
+public class IllegalAnnotationException extends IllegalArgumentException {
+
+    public IllegalAnnotationException() {
+    }
+
+    public IllegalAnnotationException(String s) {
+        super(s);
+    }
+
+    public IllegalAnnotationException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public IllegalAnnotationException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/exception/LoadClassException.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/exception/LoadClassException.java
new file mode 100644
index 0000000..ba2edbe
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/exception/LoadClassException.java
@@ -0,0 +1,12 @@
+package me.ele.lancet.weaver.internal.exception;
+
+import java.io.IOException;
+
+/**
+ * Created by gengwanpeng on 17/5/4.
+ */
+public class LoadClassException extends RuntimeException{
+    public LoadClassException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/exception/UnsupportedAnnotationException.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/exception/UnsupportedAnnotationException.java
new file mode 100644
index 0000000..7c56bf0
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/exception/UnsupportedAnnotationException.java
@@ -0,0 +1,11 @@
+package me.ele.lancet.weaver.internal.exception;
+
+/**
+ * Created by gengwanpeng on 17/5/4.
+ */
+public class UnsupportedAnnotationException extends RuntimeException{
+
+    public UnsupportedAnnotationException(String message) {
+        super(message);
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/CheckFlow.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/CheckFlow.java
new file mode 100644
index 0000000..a4e1a00
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/CheckFlow.java
@@ -0,0 +1,129 @@
+package me.ele.lancet.weaver.internal.graph;
+
+import com.android.build.api.transform.Status;
+import com.dieyidezui.lancet.rt.Scope;
+import me.ele.lancet.weaver.internal.log.Log;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * Created by gengwanpeng on 17/5/22.
+ */
+public class CheckFlow {
+
+    public Map<String, FlowEntity> map = new HashMap<>();
+
+    public void add(Graph graph, String className, Scope scope) {
+        Node node = graph.get(className);
+        if (node != null && !map.containsKey(className)) {
+            map.put(className, new FlowEntity(node.toFlowNode(scope)));
+        }
+    }
+
+    public void exactlyMatch(String className) {
+        FlowEntity entity = map.get(className);
+        if (entity != null) {
+            entity.exactMatch = true;
+        }
+    }
+
+    public boolean isIncremental(Graph graph) {
+        return map.values().stream().allMatch(f -> {
+            Node n = graph.get(f.root.className);
+            return n != null && f.check(n, graph);
+        });
+    }
+
+    public void clear() {
+        map.clear();
+    }
+
+    public static class FlowEntity {
+
+        public boolean exactMatch = false;
+        public FlowNode root;
+
+        public FlowEntity(FlowNode root) {
+            this.root = root;
+        }
+
+        public boolean check(Node n, Graph graph) {
+            if (exactMatch) {
+                return root.checkExactly(n);
+            }
+            return root.checkNormally(n, graph);
+        }
+    }
+
+
+    public static class FlowNode {
+        public String className;
+
+        public List<FlowNode> children = Collections.emptyList();
+
+        // TODO: This grain is too coarse. Now, we just judge the extend and implements flow, check if some classes lost.
+        public boolean checkExactly(Node n) {
+            if (n.checkPass[0]) {
+                return true;
+            }
+            Map<String, Node> map = directChildrenOf(n);
+            Log.d(map.size() + " " + children.size());
+            if (map.size() != children.size()) {
+                return false;
+            }
+            for (FlowNode c : children) {
+                Node child = map.get(c.className);
+                if (child == null || !c.checkExactly(child)) {
+                    return false;
+                }
+            }
+            n.checkPass[0] = true;
+            return true;
+        }
+
+        public boolean checkNormally(Node n, Graph graph) {
+            if (n.checkPass[1]) {
+                return true;
+            }
+            Map<String, Node> map = directChildrenOf(n);
+            Log.e(map.size() + " " + children.size());
+            for (FlowNode c : children) {
+                Node child = map.remove(c.className);
+                if (child == null && !c.allModified(graph)
+                        || child != null && !c.checkNormally(child, graph)) {
+                    return false;
+                }
+            }
+            if (!map.values().stream()
+                    .allMatch(FlowNode::neatInheritance)) {
+                return false;
+            }
+            n.checkPass[1] = true;
+            return true;
+        }
+
+        private boolean allModified(Graph graph) {
+            Node t;
+            return ((t = graph.get(className)) == null || t.status != Status.NOTCHANGED)
+                    && children.stream().allMatch(c -> c.allModified(graph));
+        }
+
+
+        private static boolean neatInheritance(Node n) {
+            return n.status != Status.NOTCHANGED
+                    && directChildrenOf(n).values().stream().allMatch(FlowNode::neatInheritance);
+        }
+
+        private static Map<String, Node> directChildrenOf(Node n) {
+            InterfaceNode t;
+            return n instanceof ClassNode ?
+                    ((ClassNode) n).children
+                            .stream()
+                            .collect(Collectors.toMap(v -> v.entity.name, v -> v)) :
+                    Stream.concat((t = (InterfaceNode) n).children.stream(), t.implementedClasses.stream())
+                            .collect(Collectors.toMap(v -> v.entity.name, v -> v));
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/ClassEntity.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/ClassEntity.java
new file mode 100644
index 0000000..cdf80fb
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/ClassEntity.java
@@ -0,0 +1,49 @@
+package me.ele.lancet.weaver.internal.graph;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Created by gengwanpeng on 17/5/11.
+ */
+public class ClassEntity {
+
+    public int access;
+    public String name;
+    public String superName;
+    public List<String> interfaces;
+
+    public List<FieldEntity> fields = new ArrayList<>();
+    public List<MethodEntity> methods = new ArrayList<>();
+
+    // placeholder
+    public ClassEntity(String name) {
+        this.name = name;
+        this.interfaces = Collections.emptyList();
+        this.fields = Collections.emptyList();
+        this.methods = Collections.emptyList();
+    }
+
+    // actual
+    public ClassEntity(int access, String name, String superName, List<String> interfaces) {
+        this.access = access;
+        this.name = name;
+        this.superName = superName;
+        this.interfaces = interfaces;
+        this.fields = new ArrayList<>();
+        this.methods = new ArrayList<>();
+    }
+
+    @Override
+    public String toString() {
+        return "ClassEntity{" +
+                "access=" + access +
+                ", name='" + name + '\'' +
+                ", superName='" + superName + '\'' +
+                ", interfaces=" + interfaces +
+                ", fields=" + fields +
+                ", methods=" + methods +
+                '}';
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/ClassNode.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/ClassNode.java
new file mode 100644
index 0000000..1637922
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/ClassNode.java
@@ -0,0 +1,36 @@
+package me.ele.lancet.weaver.internal.graph;
+
+import com.dieyidezui.lancet.rt.Scope;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Created by gengwanpeng on 17/5/3.
+ */
+public class ClassNode extends Node {
+
+    public List<ClassNode> children = Collections.emptyList();
+
+    public ClassNode(String className) {
+        super(new ClassEntity(className), null, Collections.emptyList());
+    }
+
+    @Override
+    public CheckFlow.FlowNode toFlowNode(Scope scope) {
+        CheckFlow.FlowNode node = new CheckFlow.FlowNode();
+        recur(node, this, scope);
+        return node;
+    }
+
+    private static void recur(CheckFlow.FlowNode node, ClassNode classNode, Scope scope) {
+        node.className = classNode.entity.name;
+        List<CheckFlow.FlowNode> list = node.children = new ArrayList<>(classNode.children.size());
+        if (scope == Scope.LEAF || scope == Scope.ALL) {
+            for (ClassNode child : classNode.children) {
+                list.add(child.toFlowNode(scope));
+            }
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/FieldEntity.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/FieldEntity.java
new file mode 100644
index 0000000..1982eca
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/FieldEntity.java
@@ -0,0 +1,26 @@
+package me.ele.lancet.weaver.internal.graph;
+
+/**
+ * Created by gengwanpeng on 17/5/11.
+ */
+public class FieldEntity {
+
+    public int access;
+    public String name;
+    public String desc;
+
+    public FieldEntity(int access, String name, String desc) {
+        this.access = access;
+        this.name = name;
+        this.desc = desc;
+    }
+
+    @Override
+    public String toString() {
+        return "FieldEntity{" +
+                "access=" + access +
+                ", name='" + name + '\'' +
+                ", desc='" + desc + '\'' +
+                '}';
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/Graph.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/Graph.java
new file mode 100644
index 0000000..a12ef0c
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/Graph.java
@@ -0,0 +1,175 @@
+package me.ele.lancet.weaver.internal.graph;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+
+import com.dieyidezui.lancet.rt.Scope;
+import me.ele.lancet.weaver.internal.log.Log;
+
+/**
+ * Created by gengwanpeng on 17/5/5.
+ * Class dependency graph.
+ */
+public class Graph {
+
+
+    private final Map<String, Node> nodeMap;
+    private final CheckFlow checkFlow;
+
+    public Graph(Map<String, Node> nodesMap, CheckFlow checkFlow) {
+        this.nodeMap = nodesMap;
+        this.checkFlow = checkFlow;
+    }
+
+    public CheckFlow flow() {
+        return checkFlow;
+    }
+
+    /**
+     * Before prepare, the Graph only has vector from child to super.
+     * this method will add vector from super to child.
+     * After prepare, there is a full graph.
+     *
+     */
+    public void prepare() {
+        nodeMap.values()
+                .forEach(n -> {
+                    if (n.parent != null) {
+                        me.ele.lancet.weaver.internal.graph.ClassNode parent = n.parent;
+                        if (parent.children == Collections.EMPTY_LIST) {
+
+                            // optimize for Object
+                            if (parent.entity.name.equals("java/lang/Object")) {
+                                parent.children = new ArrayList<>(nodeMap.size() >> 1);
+                            } else {
+                                parent.children = new ArrayList<>();
+                            }
+                        }
+                        // all interfaces extends java.lang.Object
+                        // make java.lang.Object subclasses purely
+                        if (n instanceof ClassNode) {
+                            parent.children.add((ClassNode) n);
+                        }
+                    }
+                    n.interfaces.forEach(i -> {
+                        if (n instanceof InterfaceNode) {
+                            if (i.children == Collections.EMPTY_LIST) {
+                                i.children = new ArrayList<>();
+                            }
+                            i.children.add((InterfaceNode) n);
+                        } else {
+                            if (i.implementedClasses == Collections.EMPTY_LIST) {
+                                i.implementedClasses = new ArrayList<>();
+                            }
+                            //noinspection ConstantConditions
+                            i.implementedClasses.add((me.ele.lancet.weaver.internal.graph.ClassNode) n);
+                        }
+                    });
+                });
+    }
+
+    public boolean inherit(String child, String parent) {
+        Node node = nodeMap.get(child);
+        while (node != null && !parent.equals(node.entity.name)) {
+            node = node.parent;
+        }
+        return node != null;
+    }
+
+    /**
+     * assert class always in nodeMap, if not, it's our code error.
+     */
+    public NodeVisitor childrenOf(String className, Scope scope) {
+        return visitor -> {
+            Node node = nodeMap.get(className);
+            if (node == null) {
+                visitor.accept(Node.newPlaceHolder(className));
+                Log.w("Class named " + className + " with scope '" + scope + "' is not exists in apk.");
+                return;
+            } else if (!(node instanceof ClassNode)) {
+                throw new IllegalArgumentException(className + " is not a class");
+            }
+            visitClasses((ClassNode) node, scope, visitor);
+        };
+    }
+
+    private void visitClasses(ClassNode parent, Scope scope, Consumer<Node> visitor) {
+        List<ClassNode> children = parent.children;
+        switch (scope) {
+            case SELF:
+                visitor.accept(parent);
+                break;
+            case ALL:
+                children.forEach(n -> visitClasses(n, scope, visitor));
+            case DIRECT:
+                children.forEach(visitor);
+                break;
+            case LEAF:
+                children.stream()
+                        .filter(n -> {
+                            if (n.children.size() == 0) {
+                                visitor.accept(n);
+                                return false;
+                            }
+                            return true;
+                        })
+                        .forEach(n -> visitClasses(n, scope, visitor));
+                break;
+        }
+    }
+
+    public NodeVisitor implementsOf(String interfaceName, Scope scope) {
+        return visitor -> {
+            Node node = nodeMap.get(interfaceName);
+            if (node == null) {
+                visitor.accept(Node.newPlaceHolder(interfaceName));
+                Log.w("Interface named " + interfaceName + " with scope '" + scope + "' is not exists in apk.");
+                return;
+            } else if (!(node instanceof InterfaceNode)) {
+                throw new IllegalArgumentException(interfaceName + " is not a interface");
+            }
+            visitImplements((InterfaceNode) node, scope, visitor);
+        };
+    }
+
+    private void visitImplements(InterfaceNode node, Scope scope, Consumer<Node> visitor) {
+        List<ClassNode> classes = node.implementedClasses;
+        List<InterfaceNode> children = node.children;
+        switch (scope) {
+            case ALL:
+                classes.forEach(c -> visitClasses(c, scope, visitor));
+            case DIRECT:
+                children.forEach(c -> visitImplements(c, scope, visitor));
+            case SELF:
+                classes.forEach(visitor);
+                break;
+            case LEAF:
+                children.forEach(c -> visitImplements(c, scope, visitor));
+                classes.stream()
+                        .filter(c -> {
+                            if (c.children.size() <= 0) {
+                                visitor.accept(c);
+                                return false;
+                            }
+                            return true;
+                        })
+                        .forEach(c -> visitClasses(c, scope, visitor));
+        }
+    }
+
+    public Node get(String className) {
+        return nodeMap.get(className);
+    }
+
+    public boolean checkFlow() {
+        return checkFlow.isIncremental(this);
+    }
+
+
+    public interface NodeVisitor {
+        void forEach(Consumer<Node> node);
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/InterfaceNode.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/InterfaceNode.java
new file mode 100644
index 0000000..1e73d67
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/InterfaceNode.java
@@ -0,0 +1,35 @@
+package me.ele.lancet.weaver.internal.graph;
+
+import com.dieyidezui.lancet.rt.Scope;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * Created by gengwanpeng on 17/5/3.
+ */
+public class InterfaceNode extends Node {
+
+    public List<InterfaceNode> children = Collections.emptyList();
+    public List<ClassNode> implementedClasses = Collections.emptyList();
+
+    public InterfaceNode(String className) {
+        super(new ClassEntity(className), null, Collections.emptyList());
+    }
+
+    @Override
+    public CheckFlow.FlowNode toFlowNode(Scope scope) {
+        CheckFlow.FlowNode node = new CheckFlow.FlowNode();
+        recur(node, this, scope);
+        return node;
+    }
+
+    private void recur(CheckFlow.FlowNode node, InterfaceNode interfaceNode, Scope scope) {
+        node.className = interfaceNode.entity.name;
+        List<CheckFlow.FlowNode> list = node.children = new ArrayList<>(interfaceNode.children.size() + interfaceNode.implementedClasses.size());
+        Stream.concat(interfaceNode.children.stream(), interfaceNode.implementedClasses.stream())
+                .forEach(i -> list.add(i.toFlowNode(scope)));
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/MetaGraphGenerator.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/MetaGraphGenerator.java
new file mode 100644
index 0000000..98180ff
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/MetaGraphGenerator.java
@@ -0,0 +1,11 @@
+package me.ele.lancet.weaver.internal.graph;
+
+import java.util.Map;
+
+/**
+ * Created by gengwanpeng on 17/5/2.
+ */
+public interface MetaGraphGenerator {
+
+    Graph generate();
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/MethodEntity.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/MethodEntity.java
new file mode 100644
index 0000000..0c777bb
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/MethodEntity.java
@@ -0,0 +1,26 @@
+package me.ele.lancet.weaver.internal.graph;
+
+/**
+ * Created by gengwanpeng on 17/5/11.
+ */
+public class MethodEntity {
+
+    public int access;
+    public String name;
+    public String desc;
+
+    public MethodEntity(int access, String name, String desc) {
+        this.access = access;
+        this.name = name;
+        this.desc = desc;
+    }
+
+    @Override
+    public String toString() {
+        return "MethodEntity{" +
+                "access=" + access +
+                ", name='" + name + '\'' +
+                ", desc='" + desc + '\'' +
+                '}';
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/Node.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/Node.java
new file mode 100644
index 0000000..a4f17d7
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/graph/Node.java
@@ -0,0 +1,40 @@
+package me.ele.lancet.weaver.internal.graph;
+
+import com.android.build.api.transform.Status;
+import com.dieyidezui.lancet.rt.Scope;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Created by gengwanpeng on 17/5/2.
+ */
+public abstract class Node {
+
+    // for flow check
+    public boolean[] checkPass = new boolean[2];
+    public Status status;
+
+
+    public Node(ClassEntity entity, ClassNode parent, List<InterfaceNode> interfaces) {
+        this.entity = entity;
+        this.parent = parent;
+        this.interfaces = interfaces;
+    }
+
+    public abstract CheckFlow.FlowNode toFlowNode(Scope scope);
+
+    public ClassNode parent; // null means it doesn't exists actually, it's a virtual class node
+    public List<InterfaceNode> interfaces;
+
+    public ClassEntity entity;
+
+    public static Node newPlaceHolder(String className) {
+        return new Node(new ClassEntity(className), null, Collections.emptyList()) {
+            @Override
+            public CheckFlow.FlowNode toFlowNode(Scope scope) {
+                return null;
+            }
+        };
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/ILogger.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/ILogger.java
new file mode 100644
index 0000000..6dc53d5
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/ILogger.java
@@ -0,0 +1,40 @@
+//
+//                            _ooOoo_  
+//                           o8888888o  
+//                           88" . "88  
+//                           (| -_- |)  
+//                            O\ = /O  
+//                        ____/`---'\____  
+//                      .   ' \\| |// `.  
+//                       / \\||| : |||// \  
+//                     / _||||| -:- |||||- \  
+//                       | | \\\ - /// | |  
+//                     | \_| ''\---/'' | |  
+//                      \ .-\__ `-` ___/-. /  
+//                   ___`. .' /--.--\ `. . __  
+//                ."" '< `.___\_<|>_/___.' >'"".  
+//               | | : `- \`.;`\ _ /`;.`/ - ` : | |  
+//                 \ \ `-. \_ __\ /__ _/ .-` / /  
+//         ======`-.____`-.___\_____/___.-`____.-'======  
+//                            `=---='  
+//  
+//         .............................................
+package me.ele.lancet.weaver.internal.log;
+
+/**
+ * Created by gengwanpeng on 16/7/6.
+ */
+public interface ILogger {
+
+    void d(String tag,String msg);
+
+    void i(String tag,String msg);
+
+    void w(String tag,String msg);
+
+    void w(String tag,String msg, Throwable t);
+
+    void e(String tag,String msg);
+
+    void e(String tag,String msg, Throwable t);
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Impl/BaseLogger.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Impl/BaseLogger.java
new file mode 100644
index 0000000..30f62e9
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Impl/BaseLogger.java
@@ -0,0 +1,54 @@
+package me.ele.lancet.weaver.internal.log.Impl;
+
+import org.gradle.api.logging.LogLevel;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+import me.ele.lancet.weaver.internal.log.ILogger;
+
+/**
+ * Created by gengwanpeng on 17/5/17.
+ */
+public abstract class BaseLogger implements ILogger {
+
+    @Override
+    public void d(String tag, String msg) {
+        write(LogLevel.DEBUG, tag, msg, null);
+    }
+
+    @Override
+    public void i(String tag, String msg) {
+        write(LogLevel.INFO, tag, msg, null);
+    }
+
+    @Override
+    public void w(String tag, String msg) {
+        w(tag, msg, null);
+    }
+
+    @Override
+    public void w(String tag, String msg, Throwable t) {
+        write(LogLevel.WARN, tag, msg, t);
+    }
+
+    @Override
+    public void e(String tag, String msg) {
+        e(tag, msg, null);
+    }
+
+    @Override
+    public void e(String tag, String msg, Throwable t) {
+        write(LogLevel.ERROR, tag, msg, t);
+    }
+
+    protected abstract void write(LogLevel level, String prefix, String msg, Throwable t);
+
+    static String stackToString(Throwable t) {
+        StringWriter sw = new StringWriter(128);
+        PrintWriter ps = new PrintWriter(sw);
+        t.printStackTrace(ps);
+        ps.flush();
+        return sw.toString();
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Impl/FileLoggerImpl.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Impl/FileLoggerImpl.java
new file mode 100644
index 0000000..edf7adc
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Impl/FileLoggerImpl.java
@@ -0,0 +1,55 @@
+//
+//                            _ooOoo_  
+//                           o8888888o  
+//                           88" . "88  
+//                           (| -_- |)  
+//                            O\ = /O  
+//                        ____/`---'\____  
+//                      .   ' \\| |// `.  
+//                       / \\||| : |||// \  
+//                     / _||||| -:- |||||- \  
+//                       | | \\\ - /// | |  
+//                     | \_| ''\---/'' | |  
+//                      \ .-\__ `-` ___/-. /  
+//                   ___`. .' /--.--\ `. . __  
+//                ."" '< `.___\_<|>_/___.' >'"".  
+//               | | : `- \`.;`\ _ /`;.`/ - ` : | |  
+//                 \ \ `-. \_ __\ /__ _/ .-` / /  
+//         ======`-.____`-.___\_____/___.-`____.-'======  
+//                            `=---='  
+//  
+//         .............................................
+package me.ele.lancet.weaver.internal.log.Impl;
+
+
+import org.gradle.api.logging.LogLevel;
+
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.PrintWriter;
+
+
+/**
+ * Created by gengwanpeng on 16/7/6.
+ */
+public class FileLoggerImpl extends BaseLogger {
+
+    public static FileLoggerImpl of(String fileName) throws FileNotFoundException {
+        PrintWriter pr = new PrintWriter(new FileOutputStream(fileName), true);
+        return new FileLoggerImpl(pr);
+    }
+
+    private PrintWriter pr;
+
+    private FileLoggerImpl(PrintWriter pr) {
+        this.pr = pr;
+    }
+
+    @Override
+    protected void write(LogLevel level, String prefix, String msg, Throwable t) {
+        pr.println(String.format("%s [%-10s] %s",level.name(), prefix, msg));
+        if (t != null) {
+            t.printStackTrace(pr);
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Impl/SystemLoggerImpl.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Impl/SystemLoggerImpl.java
new file mode 100644
index 0000000..c8e80d1
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Impl/SystemLoggerImpl.java
@@ -0,0 +1,43 @@
+//
+//                            _ooOoo_  
+//                           o8888888o  
+//                           88" . "88  
+//                           (| -_- |)  
+//                            O\ = /O  
+//                        ____/`---'\____  
+//                      .   ' \\| |// `.  
+//                       / \\||| : |||// \  
+//                     / _||||| -:- |||||- \  
+//                       | | \\\ - /// | |  
+//                     | \_| ''\---/'' | |  
+//                      \ .-\__ `-` ___/-. /  
+//                   ___`. .' /--.--\ `. . __  
+//                ."" '< `.___\_<|>_/___.' >'"".  
+//               | | : `- \`.;`\ _ /`;.`/ - ` : | |  
+//                 \ \ `-. \_ __\ /__ _/ .-` / /  
+//         ======`-.____`-.___\_____/___.-`____.-'======  
+//                            `=---='  
+//  
+//         .............................................
+package me.ele.lancet.weaver.internal.log.Impl;
+
+import org.gradle.api.logging.LogLevel;
+import org.gradle.api.logging.Logger;
+import org.gradle.api.logging.Logging;
+
+/**
+ * Created by gengwanpeng on 16/7/6.
+ */
+public class SystemLoggerImpl extends BaseLogger {
+
+    private final Logger logger = Logging.getLogger("lancet");
+
+    @Override
+    protected synchronized void write(LogLevel level, String prefix, String msg, Throwable t) {
+        if (t != null) {
+            logger.log(level, String.format("[%-10s] %s", prefix, msg), t);
+        } else {
+            logger.log(level, String.format("[%-10s] %s", prefix, msg));
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Impl/SystemOutputImpl.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Impl/SystemOutputImpl.java
new file mode 100644
index 0000000..8dcf9fb
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Impl/SystemOutputImpl.java
@@ -0,0 +1,44 @@
+//
+//                            _ooOoo_  
+//                           o8888888o  
+//                           88" . "88  
+//                           (| -_- |)  
+//                            O\ = /O  
+//                        ____/`---'\____  
+//                      .   ' \\| |// `.  
+//                       / \\||| : |||// \  
+//                     / _||||| -:- |||||- \  
+//                       | | \\\ - /// | |  
+//                     | \_| ''\---/'' | |  
+//                      \ .-\__ `-` ___/-. /  
+//                   ___`. .' /--.--\ `. . __  
+//                ."" '< `.___\_<|>_/___.' >'"".  
+//               | | : `- \`.;`\ _ /`;.`/ - ` : | |  
+//                 \ \ `-. \_ __\ /__ _/ .-` / /  
+//         ======`-.____`-.___\_____/___.-`____.-'======  
+//                            `=---='  
+//  
+//         .............................................
+package me.ele.lancet.weaver.internal.log.Impl;
+
+import org.gradle.api.logging.LogLevel;
+
+import java.io.PrintStream;
+
+/**
+ * Created by gengwanpeng on 16/7/6.
+ */
+public class SystemOutputImpl extends BaseLogger {
+
+    @Override
+    protected void write(LogLevel level, String prefix, String msg, Throwable t) {
+        PrintStream ps = System.out;
+        if (level == LogLevel.WARN || level == LogLevel.ERROR) {
+            ps = System.err;
+        }
+        ps.println((String.format("%s [%-10s] %s", level.name(), prefix, msg)));
+        if (t != null) {
+            ps.println(level.name() + " " + stackToString(t));
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Log.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Log.java
new file mode 100644
index 0000000..72564c0
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/log/Log.java
@@ -0,0 +1,119 @@
+//
+//                            _ooOoo_  
+//                           o8888888o  
+//                           88" . "88  
+//                           (| -_- |)  
+//                            O\ = /O  
+//                        ____/`---'\____  
+//                      .   ' \\| |// `.  
+//                       / \\||| : |||// \  
+//                     / _||||| -:- |||||- \  
+//                       | | \\\ - /// | |  
+//                     | \_| ''\---/'' | |  
+//                      \ .-\__ `-` ___/-. /  
+//                   ___`. .' /--.--\ `. . __  
+//                ."" '< `.___\_<|>_/___.' >'"".  
+//               | | : `- \`.;`\ _ /`;.`/ - ` : | |  
+//                 \ \ `-. \_ __\ /__ _/ .-` / /  
+//         ======`-.____`-.___\_____/___.-`____.-'======  
+//                            `=---='  
+//  
+//         .............................................
+package me.ele.lancet.weaver.internal.log;
+
+
+
+import me.ele.lancet.weaver.internal.log.Impl.SystemLoggerImpl;
+
+/**
+ * Created by gengwanpeng on 16/7/6.
+ */
+public class Log {
+    private static ILogger logger = new SystemLoggerImpl();
+    private static Level level = Level.INFO;
+    public static final String DEFAULT_TAG = "Lancet";
+
+    public static void setLevel(Level l) {
+        level = l;
+    }
+
+    public static void setImpl(ILogger l) {
+        logger = l;
+    }
+
+    public static Tag tag(String tag) {
+        return new Tag(tag);
+    }
+
+    public static void d(String msg) {
+        tag(DEFAULT_TAG).d(msg);
+    }
+
+    public static void i(String msg) {
+        tag(DEFAULT_TAG).i(msg);
+    }
+
+    public static void w(String msg) {
+        w(msg, null);
+    }
+
+    public static void w(String msg, Throwable t) {
+        tag(DEFAULT_TAG).w(msg, t);
+    }
+
+    public static void e(String msg) {
+        e(msg, null);
+    }
+
+    public static void e(String msg, Throwable t) {
+        tag(DEFAULT_TAG).e(msg, t);
+    }
+
+    public enum Level {
+        DEBUG, INFO, WARN, ERROR
+    }
+
+    public static class Tag {
+        private final String tag;
+
+        Tag(String tag) {
+            this.tag = tag;
+        }
+
+        public Tag d(String msg) {
+            if (level.compareTo(Level.DEBUG) <= 0) {
+                logger.d(tag, msg);
+            }
+            return this;
+        }
+
+        public Tag i(String msg) {
+            if (level.compareTo(Level.INFO) <= 0) {
+                logger.i(tag, msg);
+            }
+            return this;
+        }
+
+        public Tag w(String msg) {
+            return w(msg, null);
+        }
+
+        public Tag w(String msg, Throwable t) {
+            if (level.compareTo(Level.WARN) <= 0) {
+                logger.w(tag, msg, t);
+            }
+            return this;
+        }
+
+        public Tag e(String msg) {
+            return e(msg, null);
+        }
+
+        public Tag e(String msg, Throwable t) {
+            if (level.compareTo(Level.ERROR) <= 0) {
+                logger.e(tag, msg, t);
+            }
+            return this;
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/meta/ClassMetaInfo.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/meta/ClassMetaInfo.java
new file mode 100644
index 0000000..4fef2e6
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/meta/ClassMetaInfo.java
@@ -0,0 +1,48 @@
+package me.ele.lancet.weaver.internal.meta;
+
+import me.ele.lancet.weaver.internal.graph.Graph;
+import me.ele.lancet.weaver.internal.log.Log;
+import me.ele.lancet.weaver.internal.parser.AnnotationMeta;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Created by gengwanpeng on 17/5/3.
+ */
+public class ClassMetaInfo {
+
+    public String className;
+    public List<AnnotationMeta> annotationMetas = new ArrayList<>();
+
+    public List<MethodMetaInfo> methods = new ArrayList<>(4);
+
+    public ClassMetaInfo(String className) {
+        this.className = className;
+    }
+
+    public List<HookInfoLocator> toLocators(Graph nodeMap) {
+        return methods.stream()
+                .map(m -> {
+
+                    HookInfoLocator locator = new HookInfoLocator(nodeMap);
+                    locator.setSourceNode(className, m.sourceNode);
+
+                    annotationMetas.forEach(i -> {
+                        i.accept(locator);
+                    });
+
+                    locator.goMethod();
+
+                    m.metaList.forEach(i -> {
+                        i.accept(locator);
+                    });
+
+                    if (locator.satisfied()) {
+                        locator.transformNode();
+                    }
+                    return locator;
+                }).collect(Collectors.toList());
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/meta/HookInfoLocator.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/meta/HookInfoLocator.java
new file mode 100644
index 0000000..a3038b2
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/meta/HookInfoLocator.java
@@ -0,0 +1,200 @@
+package me.ele.lancet.weaver.internal.meta;
+
+import com.google.common.collect.Sets;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.MethodNode;
+
+import java.util.Arrays;
+import java.util.Set;
+
+import com.dieyidezui.lancet.rt.Scope;
+import me.ele.lancet.weaver.internal.entity.ProxyInfo;
+import me.ele.lancet.weaver.internal.entity.InsertInfo;
+import me.ele.lancet.weaver.internal.entity.TransformInfo;
+import me.ele.lancet.weaver.internal.entity.TryCatchInfo;
+import me.ele.lancet.weaver.internal.exception.IllegalAnnotationException;
+import me.ele.lancet.weaver.internal.graph.ClassNode;
+import me.ele.lancet.weaver.internal.graph.Graph;
+import me.ele.lancet.weaver.internal.graph.InterfaceNode;
+import me.ele.lancet.weaver.internal.graph.Node;
+import me.ele.lancet.weaver.internal.log.Log;
+import me.ele.lancet.weaver.internal.parser.AopMethodAdjuster;
+import me.ele.lancet.weaver.internal.util.TypeUtil;
+
+/**
+ * Created by gengwanpeng on 17/5/3.
+ */
+public class HookInfoLocator {
+
+    private static final int INSERT = 1;
+    private static final int PROXY = 2;
+    private static final int TRY_CATCH = 4;
+
+    private static final int PUBLIC_STATIC = Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC;
+
+    private int flag = 0;
+
+    private Set<String> classes;
+    private Set<String> tempClasses;
+
+    private String targetDesc;
+    private String targetMethod;
+    private boolean mayCreateSuper;
+    private String nameRegex;
+
+    private Type[] argsType;
+    private Type returnType;
+
+    private MethodNode sourceNode;
+    private String sourceClass;
+
+    private String flowClassName;
+    private final Graph graph;
+
+    public HookInfoLocator(Graph graph) {
+        this.graph = graph;
+    }
+
+    public Graph graph() {
+        return graph;
+    }
+
+    public Type[] getArgsType() {
+        return argsType;
+    }
+
+    public void goMethod() {
+        tempClasses = null;
+    }
+
+    public void intersectClasses(Set<String> classes) {
+        if (tempClasses == null) {
+            this.tempClasses = classes;
+        } else {
+            tempClasses = Sets.intersection(tempClasses, classes);
+        }
+        this.classes = tempClasses;
+    }
+
+    public void adjustTargetMethodArgs(int index, Type type) {
+        argsType[index] = type;
+        targetDesc = sourceNode.desc = Type.getMethodDescriptor(returnType, argsType);
+    }
+
+    public void setInsert(String targetMethod, boolean mayCreateSuper) {
+        this.flag |= INSERT;
+        this.targetMethod = targetMethod;
+        this.mayCreateSuper = mayCreateSuper;
+    }
+
+    public void setProxy(String targetMethod) {
+        this.flag |= PROXY;
+        this.targetMethod = targetMethod;
+        if (flowClassName != null) {
+            this.graph.flow()
+                    .exactlyMatch(flowClassName);
+        }
+    }
+
+    public void setTryCatch() {
+        this.flag |= TRY_CATCH;
+    }
+
+    public void setNameRegex(String regex) {
+        this.nameRegex = regex;
+    }
+
+    public void setSourceNode(String sourceClass, MethodNode node) {
+        this.sourceClass = sourceClass;
+        this.sourceNode = node;
+
+        targetDesc = sourceNode.desc;
+
+        argsType = Type.getArgumentTypes(targetDesc);
+        returnType = Type.getReturnType(targetDesc);
+    }
+
+    public void appendTo(TransformInfo transformInfo) {
+        check();
+        switch (flag) {
+            case INSERT:
+                classes.stream()
+                        .map(c -> new InsertInfo(mayCreateSuper, c, targetMethod, targetDesc, sourceClass, sourceNode))
+                        .forEach(transformInfo::addInsertInfo);
+                break;
+            case PROXY:
+                classes.stream()
+                        .map(c -> new ProxyInfo(nameRegex, c, targetMethod, targetDesc, sourceClass, sourceNode))
+                        .forEach(transformInfo::addProxyInfo);
+                break;
+            case TRY_CATCH:
+                transformInfo.addTryCatch(new TryCatchInfo(nameRegex, sourceClass, sourceNode.name, targetDesc));
+                break;
+        }
+    }
+
+    private void check() {
+        if (flag <= 0) {
+            throw new IllegalAnnotationException("no @Proxy, @Insert or @TryCatchHandler on " + sourceClass + "." + sourceNode.name);
+        } else if (Integer.bitCount(flag) > 1) {
+            throw new IllegalAnnotationException("@Proxy @Insert or @TryCatchHandler can only appear once");
+        }
+        if (flag != TRY_CATCH) {
+            if (classes == null) {
+                throw new IllegalAnnotationException("no @targetClass or @ImplementedInterface on " + sourceClass + "." + sourceNode.name);
+            }
+            if (classes.size() <= 0) {
+                Log.w("can't find satisfied class with " + sourceClass + "." + sourceNode.name);
+            }
+        } else {
+            if (!targetDesc.equals("(Ljava/lang/Throwable;)Ljava/lang/Throwable;") ||
+                    (sourceNode.access & PUBLIC_STATIC) != PUBLIC_STATIC) {
+                throw new IllegalAnnotationException("method annotated with @TryCatchHandler should be like this: " +
+                        "public static Throwable method_name(Throwable)");
+            }
+        }
+        if (mayCreateSuper && TypeUtil.isStatic(sourceNode.access)) {
+            throw new IllegalAnnotationException("can't use mayCreateSuper while method is static, " + sourceClass + "." + sourceNode.name);
+        }
+    }
+
+    public boolean satisfied() {
+        return classes != null && classes.size() > 0 && (flag == INSERT || flag == PROXY);
+    }
+
+    public void transformNode() {
+        new AopMethodAdjuster(flag == INSERT, sourceClass, sourceNode).adjust();
+    }
+
+    public void mayAddCheckFlow(String className, Scope scope) {
+        Node node = graph.get(className);
+        if (node instanceof ClassNode) {
+            if (scope == Scope.ALL || scope == Scope.LEAF) {
+                this.flowClassName = className;
+                graph.flow().add(graph, className, scope);
+            }
+        } else if (node instanceof InterfaceNode) {
+            if (scope != Scope.DIRECT) {
+                this.flowClassName = className;
+                graph.flow().add(graph, className, scope);
+            }
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "HookInfoLocator{" +
+                "flag=" + flag +
+                ", classes=" + classes +
+                ", targetDesc='" + targetDesc + '\'' +
+                ", targetMethod='" + targetMethod + '\'' +
+                ", mayCreateSuper=" + mayCreateSuper +
+                ", nameRegex='" + nameRegex + '\'' +
+                ", argsType=" + Arrays.toString(argsType) +
+                ", returnType=" + returnType +
+                ", sourceClass='" + sourceClass + '\'' +
+                '}';
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/meta/MethodMetaInfo.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/meta/MethodMetaInfo.java
new file mode 100644
index 0000000..4d3aa0d
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/meta/MethodMetaInfo.java
@@ -0,0 +1,20 @@
+package me.ele.lancet.weaver.internal.meta;
+
+import me.ele.lancet.weaver.internal.parser.AnnotationMeta;
+import org.objectweb.asm.tree.MethodNode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by gengwanpeng on 17/5/3.
+ */
+public class MethodMetaInfo {
+
+    public MethodNode sourceNode;
+    public List<AnnotationMeta> metaList;
+
+    public MethodMetaInfo(MethodNode sourceNode) {
+        this.sourceNode = sourceNode;
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AcceptableAnnoParser.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AcceptableAnnoParser.java
new file mode 100644
index 0000000..041e1c6
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AcceptableAnnoParser.java
@@ -0,0 +1,9 @@
+package me.ele.lancet.weaver.internal.parser;
+
+/**
+ * Created by gengwanpeng on 17/5/3.
+ */
+public interface AcceptableAnnoParser extends AnnoParser{
+
+    boolean accept(String desc);
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AnnoParser.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AnnoParser.java
new file mode 100644
index 0000000..0a0c79e
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AnnoParser.java
@@ -0,0 +1,12 @@
+package me.ele.lancet.weaver.internal.parser;
+
+import org.objectweb.asm.tree.AnnotationNode;
+
+/**
+ * Created by gengwanpeng on 17/5/3.
+ */
+public interface AnnoParser {
+
+
+    AnnotationMeta parseAnno(AnnotationNode annotationNode);
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AnnotationMeta.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AnnotationMeta.java
new file mode 100644
index 0000000..34c6e52
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AnnotationMeta.java
@@ -0,0 +1,17 @@
+package me.ele.lancet.weaver.internal.parser;
+
+import me.ele.lancet.weaver.internal.meta.HookInfoLocator;
+
+/**
+ * Created by gengwanpeng on 17/5/3.
+ */
+public abstract class AnnotationMeta {
+
+    public AnnotationMeta(String desc) {
+        this.desc = desc;
+    }
+
+    public String desc;
+
+    public abstract void accept(HookInfoLocator locator);
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AopMethodAdjuster.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AopMethodAdjuster.java
new file mode 100644
index 0000000..2a61370
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AopMethodAdjuster.java
@@ -0,0 +1,242 @@
+package me.ele.lancet.weaver.internal.parser;
+
+import com.dieyidezui.lancet.rt.Origin;
+import com.dieyidezui.lancet.rt.This;
+import me.ele.lancet.weaver.internal.util.PrimitiveUtil;
+import me.ele.lancet.weaver.internal.util.TypeUtil;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.*;
+
+/**
+ * Created by gengwanpeng on 17/3/28.
+ */
+public class AopMethodAdjuster {
+
+    public static final int OP_CALL = Integer.MAX_VALUE;
+    public static final int OP_THIS_GET_FIELD = OP_CALL - 1;
+    public static final int OP_THIS_PUT_FIELD = OP_THIS_GET_FIELD - 1;
+
+    public static final String JAVA_LANG_OBJECT = "java/lang/Object";
+
+
+    private final boolean allowField;
+    private final String sourceClass;
+    private final MethodNode methodNode;
+
+
+    private final CallReplacer CALL_REPLACER;
+    private final ThisReplacer THIS_REPLACER = new ThisReplacer();
+
+
+    public AopMethodAdjuster(boolean allowField, String sourceClass, MethodNode methodNode) {
+        this.allowField = allowField;
+        this.sourceClass = sourceClass;
+        this.methodNode = methodNode;
+        this.CALL_REPLACER = new CallReplacer(methodNode.desc);
+        init();
+    }
+
+    private void init() {
+        String desc = methodNode.desc;
+
+
+        // update max locals
+        int size = Type.getArgumentsAndReturnSizes(desc);
+        if (TypeUtil.isStatic(methodNode.access)) {
+            size -= 4;
+        }
+        size = Math.max(size & 3, size >> 2);
+        methodNode.maxStack = Math.max(size, methodNode.maxStack);
+    }
+
+    public void adjust() {
+        AbstractInsnNode element = methodNode.instructions.getFirst();
+        while (element != null) {
+            if (element instanceof MethodInsnNode) { //MethodInsnNode
+                element = transform((MethodInsnNode) element);
+            }
+            element = element.getNext();
+        }
+    }
+
+    private AbstractInsnNode transform(MethodInsnNode node) {
+        String owner = node.owner;
+        String name = node.name;
+        NodeReplacer replacer = NodeReplacer.IDENTITY;
+        if (owner.equals(Origin.CLASS_NAME)) {
+            if (name.startsWith("call")) {
+                replacer = this.CALL_REPLACER;
+            }
+        } else if (owner.equals(This.CLASS_NAME)) {
+            replacer = THIS_REPLACER;
+        }
+        return replacer.replace(node);
+    }
+
+    private interface NodeReplacer {
+
+        NodeReplacer IDENTITY = node -> node;
+
+        AbstractInsnNode replace(MethodInsnNode node);
+    }
+
+    private class CallReplacer implements NodeReplacer {
+
+        private static final int VOID = 1;
+        private static final int REFERENCE = 2;
+        private static final int PRIMITIVE = 3;
+        private int type;
+        private String returnType;
+
+
+        CallReplacer(String desc) {
+
+            String retDesc = desc.substring(desc.lastIndexOf(')') + 1);
+            if (retDesc.equals("V")) {// void
+                type = VOID;
+            } else if (retDesc.endsWith(";") || retDesc.charAt(0) == '[') { // object or array
+                type = REFERENCE;
+
+                if (retDesc.charAt(0) != '[' && retDesc.endsWith(";")) { //convert to internal name
+                    retDesc = retDesc.substring(1, retDesc.length() - 1);
+                }
+                returnType = retDesc;
+            } else { //primitive
+                type = PRIMITIVE;
+                returnType = PrimitiveUtil.box(retDesc);
+            }
+        }
+
+        @Override
+        public AbstractInsnNode replace(MethodInsnNode node) {
+            checkReturnType(node);
+            node.setOpcode(OP_CALL);
+            if (type != VOID && !returnType.equals(JAVA_LANG_OBJECT)) {
+                checkCast(node.getNext());
+                methodNode.instructions.remove(node.getNext());
+            }
+            if (type == PRIMITIVE) {
+                checkUnbox(node.getNext());
+                methodNode.instructions.remove(node.getNext());
+            }
+            return node;
+        }
+
+        private void checkReturnType(MethodInsnNode node) {
+            boolean has = !node.name.startsWith("callVoid");
+            boolean hasInDesc = type != VOID;
+            if (has != hasInDesc) {
+                illegalState("Called function " + node.owner + "." + node.name + "is illegal.");
+            }
+        }
+
+        private void checkCast(AbstractInsnNode insnNode) {
+            if (!(insnNode instanceof TypeInsnNode)) {
+                illegalState("Returned Object type should be cast to origin type immediately.");
+            }
+            TypeInsnNode typeInsnNode = (TypeInsnNode) insnNode;
+            if (typeInsnNode.getOpcode() != Opcodes.CHECKCAST) {
+                illegalState("Returned Object type should be cast to origin type immediately.");
+            }
+            if (!typeInsnNode.desc.equals(returnType)) {
+                illegalState("Casted type is expected to be " + returnType + " , but is " + typeInsnNode.desc);
+            }
+        }
+
+        private void checkUnbox(AbstractInsnNode insnNode) {
+            if (!(insnNode instanceof MethodInsnNode)) {
+                illegalState("Please don't unbox by your self.");
+            }
+            MethodInsnNode methodInsnNode = (MethodInsnNode) insnNode;
+            if (!methodInsnNode.owner.equals(returnType)) {
+                illegalState("Please don't unbox by your self.");
+            }
+            if (!methodInsnNode.name.equals(PrimitiveUtil.unboxMethod(returnType))) {
+                illegalState("Please don't unbox by your self.");
+            }
+        }
+    }
+
+    private class ThisReplacer implements NodeReplacer {
+
+        @Override
+        public AbstractInsnNode replace(MethodInsnNode node) {
+            if (TypeUtil.isStatic(methodNode.access)) {
+                illegalState("static method shouldn't call This's function");
+            }
+            switch (node.name) {
+                case "get":
+                    VarInsnNode varInsnNode = new VarInsnNode(Opcodes.ALOAD, 0);
+                    //TODO: Should us remove checkcast ?
+                    // getType(node.getNext());
+                    methodNode.instructions.set(node, varInsnNode);
+                    return varInsnNode;
+
+                case "getField":
+                    checkAllow(node.name);
+                    node.setOpcode(OP_THIS_GET_FIELD);
+                    node.name = getFieldName(node.getPrevious());
+                    break;
+
+                case "putField":
+                    checkAllow(node.name);
+                    node.setOpcode(OP_THIS_PUT_FIELD);
+                    node.name = getFieldName(node.getPrevious());
+                    break;
+            }
+            return node;
+        }
+
+        private void checkAllow(String name) {
+            if (!allowField) {
+                illegalState("This." + name + " only allow in @Insert");
+            }
+        }
+
+        private void removeBox(AbstractInsnNode previous) {
+            if (previous instanceof MethodInsnNode) {
+                MethodInsnNode node = (MethodInsnNode) previous;
+                if (node.getOpcode() == Opcodes.INVOKESTATIC
+                        && node.name.equals("valueOf")
+                        && PrimitiveUtil.boxedTypes().contains(node.owner)) {
+                    methodNode.instructions.remove(previous);
+                }
+            }
+        }
+
+        private String getType(AbstractInsnNode next) {
+            if (next instanceof TypeInsnNode && next.getOpcode() == Opcodes.CHECKCAST) {
+                String desc = ((TypeInsnNode) next).desc;
+                if (next.getNext() instanceof MethodInsnNode) {
+                    MethodInsnNode methodInsnNode = (MethodInsnNode) next.getNext();
+                    if (methodInsnNode.owner.equals(desc) && methodInsnNode.name.equals(PrimitiveUtil.unboxMethod(desc))) {
+                        methodNode.instructions.remove(methodInsnNode);
+                    }
+                }
+                methodNode.instructions.remove(next);
+                return desc;
+            } else {
+                return JAVA_LANG_OBJECT;
+            }
+        }
+
+        private String getFieldName(AbstractInsnNode node) {
+            if (!(node instanceof LdcInsnNode)) {
+                illegalState("only accept constant string as field name");
+            }
+            LdcInsnNode ldc = (LdcInsnNode) node;
+            if (ldc.cst == null || !(ldc.cst instanceof String)) {
+                illegalState("only accept constant string as field name");
+            }
+            String val = (String) ldc.cst;
+            methodNode.instructions.remove(node);
+            return val;
+        }
+    }
+
+
+    private void illegalState(String msg) {
+        throw new IllegalStateException("error in " + sourceClass + "." + methodNode.name + ": " + msg);
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AsmMetaParser.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AsmMetaParser.java
new file mode 100644
index 0000000..e45b15b
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/AsmMetaParser.java
@@ -0,0 +1,194 @@
+package me.ele.lancet.weaver.internal.parser;
+
+import com.google.common.base.Joiner;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.AnnotationNode;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.FieldNode;
+import org.objectweb.asm.tree.InnerClassNode;
+import org.objectweb.asm.tree.MethodNode;
+
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.net.URLConnection;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import com.dieyidezui.lancet.rt.annotations.ClassOf;
+import com.dieyidezui.lancet.rt.annotations.ImplementedInterface;
+import com.dieyidezui.lancet.rt.annotations.Insert;
+import com.dieyidezui.lancet.rt.annotations.NameRegex;
+import com.dieyidezui.lancet.rt.annotations.Proxy;
+import com.dieyidezui.lancet.rt.annotations.TargetClass;
+import com.dieyidezui.lancet.rt.annotations.TryCatchHandler;
+import me.ele.lancet.weaver.MetaParser;
+import me.ele.lancet.weaver.internal.entity.TransformInfo;
+import me.ele.lancet.weaver.internal.exception.LoadClassException;
+import me.ele.lancet.weaver.internal.exception.UnsupportedAnnotationException;
+import me.ele.lancet.weaver.internal.graph.Graph;
+import me.ele.lancet.weaver.internal.log.Log;
+import me.ele.lancet.weaver.internal.meta.ClassMetaInfo;
+import me.ele.lancet.weaver.internal.meta.MethodMetaInfo;
+import me.ele.lancet.weaver.internal.parser.anno.AcceptAny;
+import me.ele.lancet.weaver.internal.parser.anno.ClassOfAnnoParser;
+import me.ele.lancet.weaver.internal.parser.anno.DelegateAcceptableAnnoParser;
+import me.ele.lancet.weaver.internal.parser.anno.GatheredAcceptableAnnoParser;
+import me.ele.lancet.weaver.internal.parser.anno.ImplementedInterfaceAnnoParser;
+import me.ele.lancet.weaver.internal.parser.anno.InsertAnnoParser;
+import me.ele.lancet.weaver.internal.parser.anno.NameRegexAnnoParser;
+import me.ele.lancet.weaver.internal.parser.anno.ProxyAnnoParser;
+import me.ele.lancet.weaver.internal.parser.anno.TargetClassAnnoParser;
+import me.ele.lancet.weaver.internal.parser.anno.TryCatchAnnoParser;
+
+
+/**
+ * Created by gengwanpeng on 17/3/21.
+ */
+public class AsmMetaParser implements MetaParser {
+
+
+    private ClassLoader loader;
+
+    public AsmMetaParser(ClassLoader loader) {
+        this.loader = loader;
+    }
+
+    @Override
+    public TransformInfo parse(List<String> hookClasses, Graph graph) {
+        Log.i("aop classes: \n" + hookClasses.stream().collect(Collectors.joining("\n")));
+
+        return hookClasses.stream().map(s -> new AsmClassParser(loader).parse(s))
+                .map(c -> c.toLocators(graph))
+                .flatMap(Collection::stream)
+                .collect(() -> new TransformInfo(hookClasses), (t, l) -> l.appendTo(t), TransformInfo::combine);
+    }
+
+    private class AsmClassParser {
+
+        private ClassLoader cl;
+        private AcceptableAnnoParser parser;
+
+        public AsmClassParser(ClassLoader loader) {
+            this.cl = loader;
+            parser = GatheredAcceptableAnnoParser.newInstance(
+                    new DelegateAcceptableAnnoParser(Type.getDescriptor(TargetClass.class), new TargetClassAnnoParser()),
+                    new DelegateAcceptableAnnoParser(Type.getDescriptor(ImplementedInterface.class), new ImplementedInterfaceAnnoParser()),
+                    new DelegateAcceptableAnnoParser(Type.getDescriptor(Insert.class), new InsertAnnoParser()),
+                    new DelegateAcceptableAnnoParser(Type.getDescriptor(Proxy.class), new ProxyAnnoParser()),
+                    new DelegateAcceptableAnnoParser(Type.getDescriptor(TryCatchHandler.class), new TryCatchAnnoParser()),
+                    new DelegateAcceptableAnnoParser(Type.getDescriptor(NameRegex.class), new NameRegexAnnoParser()),
+                    new DelegateAcceptableAnnoParser(Type.getDescriptor(ClassOf.class), new ClassOfAnnoParser()),
+                    AcceptAny.INSTANCE
+            );
+        }
+
+        @SuppressWarnings("unchecked")
+        public ClassMetaInfo parse(String className) {
+            ClassNode cn = loadClassNode(className);
+            ClassMetaInfo meta = new ClassMetaInfo(className);
+            meta.annotationMetas = nodesToMetas(cn.visibleAnnotations);
+            meta.methods = ((List<MethodNode>) cn.methods).stream()
+                    .filter(this::checkMethod)
+                    .map(mn -> {
+                        List<AnnotationMeta> methodMetas = nodesToMetas(mn.visibleAnnotations);
+
+                        MethodMetaInfo mm = new MethodMetaInfo(mn);
+                        mm.metaList = methodMetas;
+
+                        if (mn.visibleParameterAnnotations != null) {
+                            int size = Arrays.stream(mn.visibleParameterAnnotations)
+                                    .filter(Objects::nonNull)
+                                    .mapToInt(List::size)
+                                    .sum() + methodMetas.size();
+                            List<AnnotationMeta> paramAnnoMetas = new ArrayList<>(size);
+                            for (int i = 0; i < mn.visibleParameterAnnotations.length; i++) {
+                                List<AnnotationNode> list = (List<AnnotationNode>) mn.visibleParameterAnnotations[i];
+                                if (list != null) {
+                                    for (AnnotationNode a : list) {
+                                        a.visit(ClassOf.INDEX, i);
+                                    }
+                                    paramAnnoMetas.addAll(nodesToMetas(list));
+                                }
+                            }
+
+                            paramAnnoMetas.addAll(methodMetas);
+                            mm.metaList = paramAnnoMetas;
+                        }
+
+                        return mm;
+                    })
+                    .filter(Objects::nonNull).collect(Collectors.toList());
+
+            return meta;
+        }
+
+        private List<AnnotationMeta> nodesToMetas(List<AnnotationNode> nodes) {
+            if (nodes == null || nodes.size() <= 0) {
+                return Collections.emptyList();
+            }
+            return nodes.stream().map(c -> {
+                if (!parser.accept(c.desc)) {
+                    throw new UnsupportedAnnotationException(c.desc + " is not supported");
+                }
+                return parser.parseAnno(c);
+            }).collect(Collectors.toList());
+        }
+
+        private ClassNode loadClassNode(String className) {
+            try {
+                URL url = cl.getResource(className + ".class");
+                if (url == null) {
+                    throw new IOException("url == null");
+                }
+                URLConnection urlConnection = url.openConnection();
+
+                // gradle daemon bug:
+                // Different builds in one process because of daemon which makes the jar connection will read the context from cache if they points to the same jar file.
+                // But the file may be changed.
+
+                urlConnection.setUseCaches(false);
+                ClassReader cr = new ClassReader(urlConnection.getInputStream());
+                urlConnection.getInputStream().close();
+                ClassNode cn = new ClassNode();
+                cr.accept(cn, ClassReader.SKIP_DEBUG);
+                checkNode(cn);
+                return cn;
+            } catch (IOException e) {
+                URLClassLoader cl = (URLClassLoader) this.cl;
+                throw new LoadClassException("load class failure: " + className + " by\n" + Joiner.on('\n').join(cl.getURLs()), e);
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        private void checkNode(ClassNode cn) {
+            if (cn.fields.size() > 0) {
+                String s = ((List<FieldNode>)cn.fields).stream().map(fieldNode -> fieldNode.name).collect(Collectors.joining(","));
+                Log.w("can't declare fields '"+s+"' in hook class "+cn.name);
+            }
+            int ac = Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC;
+            cn.innerClasses.forEach(c -> {
+                InnerClassNode n = (InnerClassNode) c;
+                if ((n.access & ac) != ac) {
+                    throw new IllegalStateException("inner class in hook class "+cn.name+" must be public static");
+                }
+            });
+        }
+
+        private boolean checkMethod(MethodNode methodNode) {
+            List<AnnotationNode> list = methodNode.visibleAnnotations;
+            if (list != null ){
+                return list.stream().anyMatch(annotationNode -> annotationNode.desc.contains("lancet"));
+            }
+            return false;
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/AcceptAny.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/AcceptAny.java
new file mode 100644
index 0000000..672182e
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/AcceptAny.java
@@ -0,0 +1,34 @@
+package me.ele.lancet.weaver.internal.parser.anno;
+
+import me.ele.lancet.weaver.internal.log.Log;
+import me.ele.lancet.weaver.internal.meta.HookInfoLocator;
+import me.ele.lancet.weaver.internal.parser.AcceptableAnnoParser;
+import me.ele.lancet.weaver.internal.parser.AnnotationMeta;
+import org.objectweb.asm.tree.AnnotationNode;
+
+/**
+ * Created by gengwanpeng on 17/5/4.
+ */
+public class AcceptAny implements AcceptableAnnoParser {
+
+    public static AcceptAny INSTANCE = new AcceptAny();
+
+    private AcceptAny(){
+    }
+
+    @Override
+    public boolean accept(String desc) {
+        return true;
+    }
+
+    @Override
+    public AnnotationMeta parseAnno(AnnotationNode annotationNode) {
+        Log.w("Annotation " + annotationNode.desc + " is lost.");
+        return new AnnotationMeta(annotationNode.desc) {
+
+            @Override
+            public void accept(HookInfoLocator locator) {
+            }
+        };
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/ClassOfAnnoParser.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/ClassOfAnnoParser.java
new file mode 100644
index 0000000..0202001
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/ClassOfAnnoParser.java
@@ -0,0 +1,109 @@
+package me.ele.lancet.weaver.internal.parser.anno;
+
+import com.google.common.base.Strings;
+import com.dieyidezui.lancet.rt.annotations.ClassOf;
+import me.ele.lancet.weaver.internal.exception.IllegalAnnotationException;
+import me.ele.lancet.weaver.internal.graph.Graph;
+import me.ele.lancet.weaver.internal.meta.HookInfoLocator;
+import me.ele.lancet.weaver.internal.parser.AnnoParser;
+import me.ele.lancet.weaver.internal.parser.AnnotationMeta;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.AnnotationNode;
+
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Created by gengwanpeng on 17/5/5.
+ */
+public class ClassOfAnnoParser implements AnnoParser {
+
+    private Pattern pattern = Pattern.compile("^(((?![0-9])\\w+\\.)*((?![0-9])\\w+\\$)?(?![0-9])\\w+)((\\[])*)$");
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public AnnotationMeta parseAnno(AnnotationNode annotationNode) {
+        List<Object> values;
+        String className = null;
+        int index = 0;
+        if ((values = annotationNode.values) != null) {
+            for (int i = 0; i < values.size(); i += 2) {
+                switch ((String) values.get(i)) {
+                    case "value":
+                        className = (String) values.get(i + 1);
+                        if (Strings.isNullOrEmpty(className)) {
+                            throw new IllegalAnnotationException("@ClassOf value can't be empty or null");
+                        }
+
+                        break;
+                    case ClassOf.INDEX:
+                        index = (int) values.get(i + 1);
+                        break;
+                    default:
+                        throw new IllegalAnnotationException();
+                }
+            }
+
+            Type type = Type.getType(toDesc(className));
+            return new ClassOfAnnoMeta(annotationNode.desc, index, type);
+        }
+
+        throw new IllegalAnnotationException("@ClassOf is illegal, must specify value field");
+    }
+
+    private String toDesc(String className) {
+        Matcher matcher = pattern.matcher(className);
+        if (!matcher.find()) {
+            throw new IllegalAnnotationException("value in @ClassOf is not a legal type: " + className);
+        }
+        String clazz = matcher.group(1);
+        String bracket = matcher.group(4);
+        StringBuilder sb = new StringBuilder(clazz.length() + 10);
+        if (bracket != null) {
+            for (int i = 0, j = bracket.length() >> 1; i < j; i++) {
+                sb.append('[');
+            }
+        }
+        return sb.append('L').append(clazz.replace('.', '/')).append(';').toString();
+    }
+
+    private static class ClassOfAnnoMeta extends AnnotationMeta {
+        private final int index;
+        private final Type type;
+
+        private ClassOfAnnoMeta(String desc, int index, Type type) {
+            super(desc);
+            this.index = index;
+            this.type = type;
+        }
+
+        @Override
+        public void accept(HookInfoLocator locator) {
+            Graph graph = locator.graph();
+            Type origin = locator.getArgsType()[index];
+            if (origin.getSort() != Type.OBJECT && origin.getSort() != Type.ARRAY) {
+                throw new IllegalArgumentException("@ClassOf 's origin type should be parent in value");
+            }
+
+            if (type.getDimensions() == origin.getDimensions()) {
+                if (!graph.inherit(internalClassName(type), internalClassName(origin))) {
+                    throw new IllegalArgumentException("@ClassOf 's origin type should be parent in value");
+                }
+            } else {
+                if (origin.getSort() != Type.OBJECT || !"java/lang/Object".equals(origin.getInternalName())) {
+                    throw new IllegalArgumentException("@ClassOf 's origin type should be parent in value");
+                }
+            }
+            locator.adjustTargetMethodArgs(index, type);
+        }
+
+        private String internalClassName(Type type) {
+            if (type.getSort() == Type.OBJECT) {
+                return type.getInternalName();
+            } else { // array
+                return type.getElementType().getInternalName();
+            }
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/DelegateAcceptableAnnoParser.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/DelegateAcceptableAnnoParser.java
new file mode 100644
index 0000000..ade8714
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/DelegateAcceptableAnnoParser.java
@@ -0,0 +1,31 @@
+package me.ele.lancet.weaver.internal.parser.anno;
+
+import me.ele.lancet.weaver.internal.parser.AcceptableAnnoParser;
+import me.ele.lancet.weaver.internal.parser.AnnoParser;
+import me.ele.lancet.weaver.internal.parser.AnnotationMeta;
+import org.objectweb.asm.tree.AnnotationNode;
+
+/**
+ * Created by gengwanpeng on 17/5/3.
+ */
+public class DelegateAcceptableAnnoParser implements AcceptableAnnoParser {
+
+    private final String desc;
+    private final AnnoParser parser;
+
+    public DelegateAcceptableAnnoParser(String desc, AnnoParser parser) {
+
+        this.desc = desc;
+        this.parser = parser;
+    }
+
+    @Override
+    public boolean accept(String desc) {
+        return this.desc.equals(desc);
+    }
+
+    @Override
+    public AnnotationMeta parseAnno(AnnotationNode annotationNode) {
+        return parser.parseAnno(annotationNode);
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/GatheredAcceptableAnnoParser.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/GatheredAcceptableAnnoParser.java
new file mode 100644
index 0000000..17e8132
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/GatheredAcceptableAnnoParser.java
@@ -0,0 +1,37 @@
+package me.ele.lancet.weaver.internal.parser.anno;
+
+import me.ele.lancet.weaver.internal.log.Log;
+import me.ele.lancet.weaver.internal.parser.AcceptableAnnoParser;
+import me.ele.lancet.weaver.internal.parser.AnnotationMeta;
+import org.objectweb.asm.tree.AnnotationNode;
+
+import java.util.Arrays;
+
+/**
+ * Created by gengwanpeng on 17/5/4.
+ */
+public class GatheredAcceptableAnnoParser implements AcceptableAnnoParser {
+
+    public static GatheredAcceptableAnnoParser newInstance(AcceptableAnnoParser... acceptableAnnoParsers) {
+        return new GatheredAcceptableAnnoParser(acceptableAnnoParsers);
+    }
+
+    private final AcceptableAnnoParser[] acceptableAnnoParsers;
+
+    private GatheredAcceptableAnnoParser(AcceptableAnnoParser[] acceptableAnnoParsers) {
+        this.acceptableAnnoParsers = acceptableAnnoParsers;
+    }
+
+
+    @Override
+    public boolean accept(String desc) {
+        return Arrays.stream(acceptableAnnoParsers).anyMatch(a -> a.accept(desc));
+    }
+
+    @Override
+    public AnnotationMeta parseAnno(AnnotationNode annotationNode) {
+        return Arrays.stream(acceptableAnnoParsers)
+                .filter(a -> a.accept(annotationNode.desc))
+                .findFirst().get().parseAnno(annotationNode);
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/ImplementedInterfaceAnnoParser.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/ImplementedInterfaceAnnoParser.java
new file mode 100644
index 0000000..459eb53
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/ImplementedInterfaceAnnoParser.java
@@ -0,0 +1,86 @@
+package me.ele.lancet.weaver.internal.parser.anno;
+
+import com.google.common.base.Strings;
+import com.dieyidezui.lancet.rt.Scope;
+import me.ele.lancet.weaver.internal.exception.IllegalAnnotationException;
+import me.ele.lancet.weaver.internal.meta.HookInfoLocator;
+import me.ele.lancet.weaver.internal.parser.AnnoParser;
+import me.ele.lancet.weaver.internal.parser.AnnotationMeta;
+import me.ele.lancet.weaver.internal.util.RefHolder;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.AnnotationNode;
+
+import java.util.*;
+
+/**
+ * Created by gengwanpeng on 17/5/3.
+ */
+public class ImplementedInterfaceAnnoParser implements AnnoParser {
+
+    private static final String ENUM_DESC = Type.getDescriptor(Scope.class);
+
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public AnnotationMeta parseAnno(AnnotationNode annotationNode) {
+        RefHolder<String[]> interfaces = new RefHolder<>(null);
+        RefHolder<Scope> scope = new RefHolder<>(Scope.SELF);
+
+        List<Object> values;
+        if ((values = annotationNode.values) != null) {
+            for (int i = 0; i < values.size(); i += 2) {
+                switch ((String) values.get(i)) {
+                    case "value":
+                        interfaces.set(contentNonNull(((List<String>) values.get(i + 1)).toArray(new String[0])));
+                        break;
+                    case "scope":
+                        String[] vs = (String[]) values.get(i + 1);
+                        if (!ENUM_DESC.equals(vs[0])) {
+                            throw new IllegalAnnotationException();
+                        }
+                        scope.set(Scope.valueOf(vs[1]));
+                        break;
+                    default:
+                        throw new IllegalAnnotationException();
+                }
+            }
+
+            return new AnnotationMeta(annotationNode.desc) {
+                @Override
+                public void accept(HookInfoLocator locator) {
+                    computeInterface(locator, interfaces.get(), scope.get());
+                }
+            };
+        }
+
+        throw new IllegalAnnotationException("@ImplementedInterface is illegal, must specify value field");
+    }
+
+    private static String[] contentNonNull(String[] interfaces) {
+        if (interfaces != null) {
+            for (int i = 0; i < interfaces.length; i++) {
+                if (Strings.isNullOrEmpty(interfaces[i])) {
+                    throw new IllegalAnnotationException("@ImplementedInterface's value can't be null");
+                }
+                interfaces[i] = interfaces[i].replace('.', '/');
+            }
+        }
+        return interfaces;
+    }
+
+    private void computeInterface(HookInfoLocator locator, String[] interfaces, Scope scope) {
+
+
+        Arrays.stream(interfaces)
+                .forEach(it -> {
+                    locator.mayAddCheckFlow(it, scope);
+                    Set<String> classes = new HashSet<>();
+                    locator.graph()
+                            .implementsOf(it, scope)
+                            .forEach(node -> {
+                                classes.add(node.entity.name);
+                            });
+                    locator.intersectClasses(classes);
+                });
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/InsertAnnoParser.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/InsertAnnoParser.java
new file mode 100644
index 0000000..8e0b344
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/InsertAnnoParser.java
@@ -0,0 +1,63 @@
+package me.ele.lancet.weaver.internal.parser.anno;
+
+import com.google.common.base.Strings;
+import me.ele.lancet.weaver.internal.exception.IllegalAnnotationException;
+import me.ele.lancet.weaver.internal.meta.HookInfoLocator;
+import me.ele.lancet.weaver.internal.parser.AnnoParser;
+import me.ele.lancet.weaver.internal.parser.AnnotationMeta;
+import org.objectweb.asm.tree.AnnotationNode;
+
+import java.util.List;
+
+/**
+ * Created by gengwanpeng on 17/5/5.
+ */
+public class InsertAnnoParser implements AnnoParser {
+
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public AnnotationMeta parseAnno(AnnotationNode annotationNode) {
+        List<Object> values;
+        String targetMethod = null;
+        boolean mayCreateSuper = false;
+        if ((values = annotationNode.values) != null) {
+            for (int i = 0; i < values.size(); i += 2) {
+                switch ((String) values.get(i)) {
+                    case "value":
+                        targetMethod = (String) values.get(i + 1);
+                        if (Strings.isNullOrEmpty(targetMethod)) {
+                            throw new IllegalAnnotationException("@InsertAnnoParser value can't be empty or null");
+                        }
+
+                        break;
+                    case "mayCreateSuper":
+                        mayCreateSuper = (boolean) values.get(i + 1);
+                        break;
+                    default:
+                        throw new IllegalAnnotationException();
+                }
+            }
+            return new InsertAnnoMeta(annotationNode.desc, targetMethod, mayCreateSuper);
+        }
+
+        throw new IllegalAnnotationException("@InsertAnnoParser is illegal, must specify value field");
+    }
+
+    public static class InsertAnnoMeta extends AnnotationMeta {
+
+        private final String targetMethod;
+        private final boolean mayCreateSuper;
+
+        private InsertAnnoMeta(String desc, String targetMethod, boolean mayCreateSuper) {
+            super(desc);
+            this.targetMethod = targetMethod;
+            this.mayCreateSuper = mayCreateSuper;
+        }
+
+        @Override
+        public void accept(HookInfoLocator locator) {
+            locator.setInsert(targetMethod, mayCreateSuper);
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/NameRegexAnnoParser.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/NameRegexAnnoParser.java
new file mode 100644
index 0000000..a18c4cf
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/NameRegexAnnoParser.java
@@ -0,0 +1,48 @@
+package me.ele.lancet.weaver.internal.parser.anno;
+
+import com.google.common.base.Strings;
+import me.ele.lancet.weaver.internal.exception.IllegalAnnotationException;
+import me.ele.lancet.weaver.internal.meta.HookInfoLocator;
+import me.ele.lancet.weaver.internal.parser.AnnoParser;
+import me.ele.lancet.weaver.internal.parser.AnnotationMeta;
+import me.ele.lancet.weaver.internal.util.RefHolder;
+import org.objectweb.asm.tree.AnnotationNode;
+
+import java.util.List;
+
+/**
+ * Created by gengwanpeng on 17/5/5.
+ */
+public class NameRegexAnnoParser implements AnnoParser {
+
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public AnnotationMeta parseAnno(AnnotationNode annotationNode) {
+        List<Object> values;
+        RefHolder<String> regex = new RefHolder<>(null);
+        if ((values = annotationNode.values) != null) {
+            for (int i = 0; i < values.size(); i += 2) {
+                switch ((String) values.get(i)) {
+                    case "value":
+                        regex.set((String) values.get(i + 1));
+                        if (Strings.isNullOrEmpty(regex.get())) {
+                            throw new IllegalAnnotationException("@NameRegexAnnoParser value can't be empty or null");
+                        }
+
+                        break;
+                    default:
+                        throw new IllegalAnnotationException();
+                }
+            }
+            return new AnnotationMeta(annotationNode.desc) {
+                @Override
+                public void accept(HookInfoLocator locator) {
+                    locator.setNameRegex(regex.get());
+                }
+            };
+        }
+
+        throw new IllegalAnnotationException("@NameRegexAnnoParser is illegal, must specify value field");
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/ProxyAnnoParser.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/ProxyAnnoParser.java
new file mode 100644
index 0000000..6e684cd
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/ProxyAnnoParser.java
@@ -0,0 +1,57 @@
+package me.ele.lancet.weaver.internal.parser.anno;
+
+import com.google.common.base.Strings;
+import me.ele.lancet.weaver.internal.exception.IllegalAnnotationException;
+import me.ele.lancet.weaver.internal.meta.HookInfoLocator;
+import me.ele.lancet.weaver.internal.parser.AnnoParser;
+import me.ele.lancet.weaver.internal.parser.AnnotationMeta;
+import org.objectweb.asm.tree.AnnotationNode;
+
+import java.util.List;
+
+/**
+ * Created by gengwanpeng on 17/5/5.
+ */
+public class ProxyAnnoParser implements AnnoParser {
+
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public AnnotationMeta parseAnno(AnnotationNode annotationNode) {
+        List<Object> values;
+        String targetMethod = null;
+        if ((values = annotationNode.values) != null) {
+            for (int i = 0; i < values.size(); i += 2) {
+                switch ((String) values.get(i)) {
+                    case "value":
+                        targetMethod = (String) values.get(i + 1);
+                        if (Strings.isNullOrEmpty(targetMethod)) {
+                            throw new IllegalAnnotationException("@Proxy value can't be empty or null");
+                        }
+
+                        break;
+                    default:
+                        throw new IllegalAnnotationException();
+                }
+            }
+            return new ProxyAnnoMeta(annotationNode.desc, targetMethod);
+        }
+
+        throw new IllegalAnnotationException("@Proxy is illegal, must specify value field");
+    }
+
+    public static class ProxyAnnoMeta extends AnnotationMeta {
+
+        private final String targetMethod;
+
+        private ProxyAnnoMeta(String desc, String targetMethod) {
+            super(desc);
+            this.targetMethod = targetMethod;
+        }
+
+        @Override
+        public void accept(HookInfoLocator locator) {
+            locator.setProxy(targetMethod);
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/TargetClassAnnoParser.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/TargetClassAnnoParser.java
new file mode 100644
index 0000000..f1e7033
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/TargetClassAnnoParser.java
@@ -0,0 +1,73 @@
+package me.ele.lancet.weaver.internal.parser.anno;
+
+import com.google.common.base.Strings;
+import com.dieyidezui.lancet.rt.Scope;
+import me.ele.lancet.weaver.internal.exception.IllegalAnnotationException;
+import me.ele.lancet.weaver.internal.meta.HookInfoLocator;
+import me.ele.lancet.weaver.internal.parser.AnnoParser;
+import me.ele.lancet.weaver.internal.parser.AnnotationMeta;
+import me.ele.lancet.weaver.internal.util.RefHolder;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.AnnotationNode;
+
+import java.util.*;
+
+/**
+ * Created by gengwanpeng on 17/5/3.
+ */
+public class TargetClassAnnoParser implements AnnoParser {
+
+    private static final String ENUM_DESC = Type.getDescriptor(Scope.class);
+
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public AnnotationMeta parseAnno(AnnotationNode annotationNode) {
+        RefHolder<String> className = new RefHolder<>(null);
+        RefHolder<Scope> scope = new RefHolder<>(Scope.SELF);
+
+        List<Object> values;
+        if ((values = annotationNode.values) != null) {
+            for (int i = 0; i < values.size(); i += 2) {
+                switch ((String) values.get(i)) {
+                    case "value":
+                        String temp = (String) values.get(i + 1);
+                        if (Strings.isNullOrEmpty(temp)) {
+                            throw new IllegalAnnotationException("@TargetClass value can't be empty or null");
+                        }
+                        className.set(temp.replace('.', '/'));
+                        break;
+                    case "scope":
+                        String[] vs = (String[]) values.get(i + 1);
+                        if (!ENUM_DESC.equals(vs[0])) {
+                            throw new IllegalAnnotationException();
+                        }
+                        scope.set(Scope.valueOf(vs[1]));
+                        break;
+                    default:
+                        throw new IllegalAnnotationException();
+                }
+            }
+
+            return new AnnotationMeta(annotationNode.desc) {
+                @Override
+                public void accept(HookInfoLocator locator) {
+                    computeClass(locator, className.get(), scope.get());
+                }
+            };
+        }
+
+        throw new IllegalAnnotationException("@TargetClass is illegal, must specify value field");
+    }
+
+    private void computeClass(HookInfoLocator locator, String className, Scope scope) {
+        locator.mayAddCheckFlow(className, scope);
+        Set<String> classes = new HashSet<>();
+        locator.graph()
+                .childrenOf(className, scope)
+                .forEach(node -> {
+                    classes.add(node.entity.name);
+                });
+        locator.intersectClasses(classes);
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/TryCatchAnnoParser.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/TryCatchAnnoParser.java
new file mode 100644
index 0000000..7b2a77b
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/parser/anno/TryCatchAnnoParser.java
@@ -0,0 +1,30 @@
+package me.ele.lancet.weaver.internal.parser.anno;
+
+import me.ele.lancet.weaver.internal.meta.HookInfoLocator;
+import me.ele.lancet.weaver.internal.parser.AnnoParser;
+import me.ele.lancet.weaver.internal.parser.AnnotationMeta;
+import org.objectweb.asm.tree.AnnotationNode;
+
+/**
+ * Created by gengwanpeng on 17/5/5.
+ */
+public class TryCatchAnnoParser implements AnnoParser {
+
+    @Override
+    public AnnotationMeta parseAnno(AnnotationNode annotationNode) {
+        return new TryCatchAnnoMeta(annotationNode.desc);
+    }
+
+    public class TryCatchAnnoMeta extends AnnotationMeta {
+
+
+        public TryCatchAnnoMeta(String desc) {
+            super(desc);
+        }
+
+        @Override
+        public void accept(HookInfoLocator locator) {
+            locator.setTryCatch();
+        }
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/AsmUtil.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/AsmUtil.java
new file mode 100644
index 0000000..5fa2165
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/AsmUtil.java
@@ -0,0 +1,18 @@
+package me.ele.lancet.weaver.internal.util;
+
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.MethodNode;
+
+/**
+ * Created by gengwanpeng on 17/4/11.
+ */
+public class AsmUtil {
+
+    public static MethodNode clone(MethodNode node) {
+        MethodNode clone = new MethodNode(Opcodes.ASM5, node.access, node.name, node.desc, node.signature,
+                (String[]) node.exceptions.toArray(new String[node.exceptions.size()]));
+        node.accept(clone);
+        return clone;
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/Bitset.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/Bitset.java
new file mode 100644
index 0000000..f478eda
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/Bitset.java
@@ -0,0 +1,88 @@
+package me.ele.lancet.weaver.internal.util;
+
+import java.util.Arrays;
+import java.util.function.Consumer;
+
+/**
+ * Created by gengwanpeng on 17/5/10.
+ */
+public class Bitset {
+
+    private static final int[] EMPTY = new int[0];
+
+    private int[] bits;
+
+    int next = 0;
+    private Consumer<Bitset> initializer;
+
+    public Bitset() {
+        bits = EMPTY;
+    }
+
+    public void tryAdd(String intLike, int index) {
+        int res = 0;
+        while (index < intLike.length()) {
+            int e = intLike.charAt(index) - '0';
+            if (e < 0 || e > 9) return;
+            res = res * 10 + e;
+            index++;
+        }
+        add(res);
+    }
+
+    private void add(int bit) {
+        ensureCapacity(bit);
+        bits[bit >> 5] |= (1 << (bit & 31));
+        if (bit == next) {
+            moveToNext();
+        }
+    }
+
+    private void moveToNext() {
+        int i = next;
+        int[] localBits = bits;
+        while (((localBits[i >> 5] >> (i & 31)) & 1) != 0) {
+            i++;
+        }
+        next = i;
+    }
+
+    private void ensureCapacity(int bit) {
+        if (bit > Integer.MAX_VALUE - 31) {
+            throw new OutOfMemoryError();
+        }
+        bit = (bit >> 5) + 1;
+        if (bits == EMPTY) {
+            bits = new int[minPow(bit)];
+        } else if (bit > bits.length) {
+            int bl = bits.length << 1;
+            bits = Arrays.copyOf(bits, bit <= bl ? bl : minPow(bit));
+        }
+    }
+
+    private static int minPow(int i) {
+        i |= i >> 1;
+        i |= i >> 2;
+        i |= i >> 4;
+        i |= i >> 8;
+        i |= i >> 16;
+        return i + 1;
+    }
+
+    public int consume() {
+        init();
+        int i = next;
+        add(i);
+        return i;
+    }
+
+    private void init() {
+        if (bits == EMPTY) {
+            initializer.accept(this);
+        }
+    }
+
+    public void setInitializer(Consumer<Bitset> initializer) {
+        this.initializer = initializer;
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/PrimitiveUtil.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/PrimitiveUtil.java
new file mode 100644
index 0000000..edb7efb
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/PrimitiveUtil.java
@@ -0,0 +1,103 @@
+package me.ele.lancet.weaver.internal.util;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Created by gengwanpeng on 17/3/28.
+ */
+public class PrimitiveUtil {
+    private static Map<String, String> boxMap;
+    private static Map<String, String> unboxMap;
+    private static Map<String, String> methodMap;
+    private static Set<String> numberTypes;
+
+    static {
+        boxMap = new HashMap<>(8);
+        boxMap.put("Z", "java/lang/Boolean");
+        boxMap.put("C", "java/lang/Character");
+        boxMap.put("B", "java/lang/Byte");
+        boxMap.put("S", "java/lang/Short");
+        boxMap.put("I", "java/lang/Integer");
+        boxMap.put("F", "java/lang/Float");
+        boxMap.put("J", "java/lang/Long");
+        boxMap.put("D", "java/lang/Double");
+
+        unboxMap = new HashMap<>(8);
+        unboxMap.put("java/lang/Boolean", "Z");
+        unboxMap.put("java/lang/Character", "C");
+        unboxMap.put("java/lang/Byte", "B");
+        unboxMap.put("java/lang/Short", "S");
+        unboxMap.put("java/lang/Integer", "I");
+        unboxMap.put("java/lang/Float", "F");
+        unboxMap.put("java/lang/Long", "J");
+        unboxMap.put("java/lang/Double", "D");
+
+        methodMap = new HashMap<>(8);
+        methodMap.put("java/lang/Boolean", "booleanValue");
+        methodMap.put("java/lang/Character", "charValue");
+        methodMap.put("java/lang/Byte", "byteValue");
+        methodMap.put("java/lang/Short", "shortValue");
+        methodMap.put("java/lang/Integer", "intValue");
+        methodMap.put("java/lang/Float", "floatValue");
+        methodMap.put("java/lang/Long", "longValue");
+        methodMap.put("java/lang/Double", "doubleValue");
+
+        numberTypes = new HashSet<>();
+        numberTypes.add("java/lang/Byte");
+        numberTypes.add("java/lang/Short");
+        numberTypes.add("java/lang/Integer");
+        numberTypes.add("java/lang/Float");
+        numberTypes.add("java/lang/Long");
+        numberTypes.add("java/lang/Double");
+    }
+
+
+    public static String box(String primitive) {
+        String clazz = boxMap.get(primitive);
+        if (clazz == null) {
+            throw new IllegalArgumentException("The primitive type '" + primitive + "' is illegal.");
+        }
+        return clazz;
+    }
+
+    public static String unbox(String type) {
+        String ret = unboxMap.get(type);
+        if (ret == null) {
+            throw new IllegalArgumentException("The unbox type '" + type + "' is illegal.");
+        }
+        return ret;
+    }
+
+    public static String unboxMethod(String clazz) {
+        String method = methodMap.get(clazz);
+        if (method == null) {
+            throw new IllegalArgumentException("Box class " + clazz + " is illegal.");
+        }
+        return method;
+    }
+
+    public static boolean isPrimitive(String s) {
+        return boxMap.containsKey(s);
+    }
+
+
+    public static Set<String> boxedTypes() {
+        return methodMap.keySet();
+    }
+
+    public static String virtualType(String owner) {
+        if (numberTypes.contains(owner)) {
+            return "java/lang/Number";
+        }
+        return owner;
+    }
+
+    public static Set<String> boxedNumberTypes() {
+        return numberTypes;
+    }
+
+
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/RefHolder.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/RefHolder.java
new file mode 100644
index 0000000..03a811d
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/RefHolder.java
@@ -0,0 +1,21 @@
+package me.ele.lancet.weaver.internal.util;
+
+/**
+ * Created by gengwanpeng on 17/5/5.
+ */
+public class RefHolder<T> {
+
+    private T val;
+
+    public RefHolder(T val) {
+        this.val = val;
+    }
+
+    public void set(T val) {
+        this.val = val;
+    }
+
+    public T get() {
+        return val;
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/TraceUtil.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/TraceUtil.java
new file mode 100644
index 0000000..c222713
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/TraceUtil.java
@@ -0,0 +1,76 @@
+package me.ele.lancet.weaver.internal.util;
+
+import me.ele.lancet.weaver.internal.log.Log;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.util.ASMifier;
+import org.objectweb.asm.util.Printer;
+import org.objectweb.asm.util.TraceClassVisitor;
+import org.objectweb.asm.util.TraceMethodVisitor;
+
+import java.io.PrintWriter;
+import java.io.StringWriter;
+
+/**
+ * Created by gengwanpeng on 17/4/7.
+ */
+public class TraceUtil {
+
+
+    public static ClassVisitor dump(ClassVisitor next) {
+        return new ClassNode(Opcodes.ASM5) {
+            @Override
+            public void visitEnd() {
+                super.visitEnd();
+                StringWriter sw = new StringWriter();
+                PrintWriter pw = new PrintWriter(sw);
+                ClassVisitor cv = new TraceClassVisitor(null, new ASMifier(), pw);
+                accept(cv);
+                Log.e(sw.toString());
+                if (next != null) {
+                    accept(next);
+                }
+            }
+        };
+    }
+
+    public static MethodVisitor dump(MethodVisitor next) {
+        return new MethodNode(Opcodes.ASM5) {
+
+            @Override
+            public void visitEnd() {
+                super.visitEnd();
+                StringWriter sw = new StringWriter();
+                PrintWriter pw = new PrintWriter(sw);
+                Printer printer = new ASMifier();
+                TraceMethodVisitor traceMv = new TraceMethodVisitor(printer);
+                accept(traceMv);
+                printer.print(pw);
+                System.out.println(sw);
+                if (next != null) {
+                    accept(next);
+                }
+            }
+        };
+    }
+
+
+    public static MethodVisitor dumpOnly() {
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw);
+        Printer printer = new ASMifier();
+        TraceMethodVisitor traceMv = new TraceMethodVisitor(printer);
+        return new MethodVisitor(Opcodes.ASM5,traceMv) {
+
+            @Override
+            public void visitEnd() {
+                super.visitEnd();
+                printer.print(pw);
+                System.out.println(sw);
+            }
+        };
+    }
+}
diff --git a/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/TypeUtil.java b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/TypeUtil.java
new file mode 100644
index 0000000..c61652c
--- /dev/null
+++ b/lancet-weaver/src/main/java/me/ele/lancet/weaver/internal/util/TypeUtil.java
@@ -0,0 +1,75 @@
+package me.ele.lancet.weaver.internal.util;
+
+import org.objectweb.asm.Opcodes;
+
+/**
+ * Created by gengwanpeng on 17/3/31.
+ */
+public class TypeUtil {
+
+    public static String removeFirstParam(String desc) {
+        if (desc.startsWith("()")) {
+            return desc;
+        }
+        int index = 1;
+        char c = desc.charAt(index);
+        while (c == '[') {
+            index++;
+            c = desc.charAt(index);
+        }
+        if (c == 'L') {
+            while (desc.charAt(index) != ';') {
+                index++;
+            }
+        }
+        return "(" + desc.substring(index + 1);
+    }
+
+    public static String descToStatic(int access, String desc, String className) {
+        if ((access & Opcodes.ACC_STATIC) == 0) {
+            desc = "(L" + className.replace('.', '/') + ";" + desc.substring(1);
+        }
+        return desc;
+    }
+
+    public static String descToNonStatic(String desc) {
+        return "(" + desc.substring(desc.indexOf(';') + 1);
+    }
+
+    public static int parseArray(int index, String desc) {
+        while (desc.charAt(index) == '[') index++;
+        if (desc.charAt(index) == 'L') {
+            while (desc.charAt(index) != ';') index++;
+        }
+        return index;
+    }
+
+    public static int parseObject(int index, String desc) {
+        while (desc.charAt(index) != ';') index++;
+        return index;
+    }
+
+    public static boolean isStatic(int access){
+        return (access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC;
+    }
+
+    public static boolean isAbstract(int access){
+        return (access & Opcodes.ACC_ABSTRACT) == Opcodes.ACC_ABSTRACT;
+    }
+
+    public static boolean isSynthetic(int access){
+        return (access & Opcodes.ACC_SYNTHETIC) == Opcodes.ACC_SYNTHETIC;
+    }
+
+    public static boolean isPrivate(int access) {
+        return (access & Opcodes.ACC_PRIVATE) == Opcodes.ACC_PRIVATE;
+    }
+
+    public static boolean isPublic(int access) {
+        return (access & Opcodes.ACC_PUBLIC) == Opcodes.ACC_PUBLIC;
+    }
+
+    public static int resetAccessScope(int access,int scope){
+        return access & ~(Opcodes.ACC_PRIVATE | Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED) | scope;
+    }
+}
diff --git a/media/14948409810841/scope.png b/media/14948409810841/scope.png
new file mode 100644
index 0000000..c5f6fc3
Binary files /dev/null and b/media/14948409810841/scope.png differ
diff --git a/settings.gradle b/settings.gradle
new file mode 100644
index 0000000..45de3e7
--- /dev/null
+++ b/settings.gradle
@@ -0,0 +1,3 @@
+include ':lancet-base', ':lancet-weaver', ':lancet-plugin'
+rootProject.name = "Lancet"
+