添加javapoet

gradle.properties

@@ -8,8 +8,10 @@
 # The setting is particularly useful for tweaking memory settings.
 android.enableJetifier=true
 android.useAndroidX=true
-org.gradle.jvmargs=-Xmx1536m
+#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
+org.gradle.daemon=true
+org.gradle.jvmargs=-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005

settings.gradle

@@ -1 +1 @@
-include ':app', ':view-inject-annotation', ':view-inject-compiler', ':view-inject-api', ':temp'
+include ':app', ':view-inject-annotation', ':view-inject-compiler', ':view-inject-api', ':temp'

temp/build.gradle

@@ -30,8 +30,5 @@ dependencies {
     testImplementation 'junit:junit:4.12'
     androidTestImplementation 'androidx.test:runner:1.2.0'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
-    implementation 'com.google.auto.service:auto-service:1.0-rc3'
-    implementation project(':view-inject-annotation')
-    implementation files('libs/javax.annotation-api-1.3.2.jar')
-    implementation files('libs/javax.jar')
+
 }

view-inject-compiler/build.gradle

@@ -4,6 +4,7 @@ dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation 'com.google.auto.service:auto-service:1.0-rc3'
     implementation project(':view-inject-annotation')
+    implementation 'com.squareup:javapoet:1.11.1'
 }
 
 sourceCompatibility = "8"

view-inject-compiler/src/main/java/com/huangyuanlove/view_inject_compiler/test/Main.java

@@ -0,0 +1,30 @@
+package com.huangyuanlove.view_inject_compiler.test;
+
+
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeSpec;
+
+import java.io.File;
+
+public class Main {
+
+    public static void main(String[] args) {
+        TypeSpec main = TypeSpec.classBuilder("TestAll")
+                .addSuperinterface(ParameterizedTypeName.get((Comparable.class), String.class))
+                .build();
+
+
+
+        JavaFile javaFile = JavaFile.builder("com.huangyuanlove.view_inject_compiler.test", main).build();
+        try {
+            javaFile.writeTo(new File("view-inject-compiler/src/main/java"));
+        }
+        catch (Exception e){
+            e.printStackTrace();
+        }
+
+
+    }
+
+}

view-inject-compiler/src/main/java/com/huangyuanlove/view_inject_compiler/test/TestJavaPoet.java

@@ -0,0 +1,228 @@
+package com.huangyuanlove.view_inject_compiler.test;
+
+
+import com.squareup.javapoet.ClassName;
+import com.squareup.javapoet.CodeBlock;
+import com.squareup.javapoet.FieldSpec;
+import com.squareup.javapoet.JavaFile;
+import com.squareup.javapoet.MethodSpec;
+import com.squareup.javapoet.ParameterizedTypeName;
+import com.squareup.javapoet.TypeName;
+import com.squareup.javapoet.TypeSpec;
+import com.squareup.javapoet.TypeVariableName;
+import com.squareup.javapoet.WildcardTypeName;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.lang.model.element.Modifier;
+
+
+public class TestJavaPoet {
+    public static void main(String[] args) {
+        TypeSpec clazz = clazz(builtinTypeField(),          // int
+                arrayTypeField(),            // int[]
+                refTypeField(),              // File
+                typeField(),                 // T
+                parameterizedTypeField(),    // List<String>
+                wildcardTypeField(),         // List<? extends String>
+                constructor(),               // 构造函数
+                method(code()));             // 普通方法
+        JavaFile javaFile = JavaFile.builder("com.huangyuanlove.view_inject_compiler.test", clazz).build();
+
+        System.out.println(javaFile.toString());
+    }
+
+    /**
+     * `public abstract class Clazz<T> extends String implements Serializable, Comparable<String>, Comparable<? extends String> {
+     * ...
+
+     */
+    private static TypeSpec clazz(FieldSpec builtinTypeField, FieldSpec arrayTypeField, FieldSpec refTypeField,
+                                 FieldSpec typeField, FieldSpec parameterizedTypeField, FieldSpec wildcardTypeField,
+                                 MethodSpec constructor, MethodSpec methodSpec) {
+        return TypeSpec.classBuilder("Clazz")
+                // 限定符
+                .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
+                // 泛型
+                .addTypeVariable(TypeVariableName.get("T"))
+
+                // 继承与接口
+                .superclass(String.class)
+                .addSuperinterface(Serializable.class)
+                .addSuperinterface(ParameterizedTypeName.get(Comparable.class, String.class))
+                .addSuperinterface(ParameterizedTypeName.get(ClassName.get(Map.class),
+                        TypeVariableName.get("T"),
+                        WildcardTypeName.subtypeOf(String.class)))
+
+                // 初始化块
+                .addStaticBlock(CodeBlock.builder().build())
+                .addInitializerBlock(CodeBlock.builder().build())
+
+                // 属性
+                .addField(builtinTypeField)
+                .addField(arrayTypeField)
+                .addField(refTypeField)
+                .addField(typeField)
+                .addField(parameterizedTypeField)
+                .addField(wildcardTypeField)
+
+                // 方法 （构造函数也在此定义）
+                .addMethod(constructor)
+                .addMethod(methodSpec)
+
+                // 内部类
+                .addType(TypeSpec.classBuilder("InnerClass").build())
+
+                .build();
+    }
+
+    /**
+     * 内置类型
+     */
+    private static FieldSpec builtinTypeField() {
+        // private int mInt;
+        return FieldSpec.builder(int.class, "mInt", Modifier.PRIVATE).build();
+    }
+
+    /**
+     * 数组类型
+     */
+    private static FieldSpec arrayTypeField() {
+        // private int[] mArr;
+        return FieldSpec.builder(int[].class, "mArr", Modifier.PRIVATE).build();
+    }
+
+    /**
+     * 需要导入 import 的类型
+     */
+    private static FieldSpec refTypeField() {
+        // private File mRef;
+        return FieldSpec.builder(File.class, "mRef", Modifier.PRIVATE).build();
+    }
+
+    /**
+     * 泛型
+     */
+    private static FieldSpec typeField() {
+        // private File mT;
+        return FieldSpec.builder(TypeVariableName.get("T"), "mT", Modifier.PRIVATE).build();
+    }
+
+    /**
+     * 参数化类型
+     */
+    private static FieldSpec parameterizedTypeField() {
+        // private List<String> mParameterizedField;
+        return FieldSpec.builder(ParameterizedTypeName.get(List.class, String.class),
+                "mParameterizedField",
+                Modifier.PRIVATE)
+                .build();
+    }
+
+    /**
+     * 通配符参数化类型
+     */
+    private static FieldSpec wildcardTypeField() {
+        // private List<? extends String> mWildcardField;
+        return FieldSpec.builder(ParameterizedTypeName.get(ClassName.get(List.class),
+                WildcardTypeName.subtypeOf(String.class)),
+                "mWildcardField",
+                Modifier.PRIVATE)
+                .build();
+    }
+
+    /**
+     * 构造函数
+     */
+    private static MethodSpec constructor() {
+        return MethodSpec.constructorBuilder()
+                .addModifiers(Modifier.PUBLIC)
+                .build();
+    }
+
+    /**
+     * `@Override
+     * public <T> Integer method(String string, T t, Map<Integer, ? extends T> map) throws IOException, RuntimeException {
+     * ...
+     * }`
+     *
+     */
+    private static MethodSpec method(CodeBlock codeBlock) {
+        return MethodSpec.methodBuilder("method")
+                .addAnnotation(Override.class)
+                .addTypeVariable(TypeVariableName.get("T"))
+                .addModifiers(Modifier.PUBLIC)
+                .returns(int.class)
+                .addParameter(String.class, "string")
+                .addParameter(TypeVariableName.get("T"), "t")
+                .addParameter(ParameterizedTypeName.get(ClassName.get(Map.class),
+                        ClassName.get(Integer.class),
+                        WildcardTypeName.subtypeOf(TypeVariableName.get("T"))),
+                        "map")
+                .addException(IOException.class)
+                .addException(RuntimeException.class)
+                .addCode(codeBlock)
+                .build();
+    }
+
+    /**
+     * ‘method’ 方法中的具体语句
+     */
+    private static CodeBlock code() {
+        return CodeBlock.builder()
+                .addStatement("int foo = 1")
+                .addStatement("$T bar = $S", String.class, "a string")
+
+                // Object obj = new HashMap<Integer, ? extends T>(5);
+                .addStatement("$T obj = new $T(5)",
+                        Object.class, ParameterizedTypeName.get(ClassName.get(HashMap.class),
+                                ClassName.get(Integer.class),
+                                WildcardTypeName.subtypeOf(TypeVariableName.get("T"))))
+
+                // method(new Runnable(String param) {
+                //   @Override
+                //   void run() {
+                //   }
+                // });
+                .addStatement("baz($L)", TypeSpec.anonymousClassBuilder("$T param", String.class)
+                        .superclass(Runnable.class)
+                        .addMethod(MethodSpec.methodBuilder("run")
+                                .addAnnotation(Override.class)
+                                .returns(TypeName.VOID)
+                                .build())
+                        .build())
+
+                // for
+                .beginControlFlow("for (int i = 0; i < 5; i++)")
+                .endControlFlow()
+
+                // while
+                .beginControlFlow("while (false)")
+                .endControlFlow()
+
+                // do... while
+                .beginControlFlow("do")
+                .endControlFlow("while (false)")
+
+                // if... else if... else...
+                .beginControlFlow("if (false)")
+                .nextControlFlow("else if (false)")
+                .nextControlFlow("else")
+                .endControlFlow()
+
+                // try... catch... finally
+                .beginControlFlow("try")
+                .nextControlFlow("catch ($T e)", Exception.class)
+                .addStatement("e.printStackTrace()")
+                .nextControlFlow("finally")
+                .endControlFlow()
+
+                .addStatement("return 0")
+                .build();
+    }
+}