前言

在前面的Android6.0权限处理不再复杂文章中，介绍过一个开源框架PermissionsDispatcher(权限调度者)框架，基于该框架的条件下，有了介绍注解以及注解APT的两篇文章，分别是：

Android进阶之Annotation(注解)的使用

Android编译时，怎么自动生成代码？

在【Android编译时，怎么自动生成代码？】这篇文章的结尾中，提到过可以使用JavaPoet来优雅的生成代码。那今天我们的主要内容就是来介绍一下【JavaPoet】该开源框架。

环境的搭建

1，新建项目名为【myJavaPoet】的Android项目；
2，在其中新建Module名为【poet】的模块，选择【Java Library】，如下：

Java Library

PS：

JavaPoet必须在Java Library中使用，例如在rt.jar包中的javax包属于Android核心库中没有，所以不能直接在app Module和Android Library中使用，必须要创建一个Java Library，然后由Java Library导出jar包使用，如下图：

rt.jar

3，在【poet.build.gradle】中，添加如下信息：

dependencies {
    compile 'com.squareup:javapoet:1.8.0'
}

完成后的项目目录结构如下：

项目目录结构

下面开始讲例子，希望看例子的时候，注释切记一定要多注意看~~~

例子1，PoetHello

主要讲的是类、方法的生成，在其中添加修饰、返回类型、抽象方法，以及如何写入文件系统等等。。。

PoetHello的代码如下：

package com.example;


import com.squareup.javapoet.JavaFile;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.TypeSpec;

import java.io.File;

import javax.lang.model.element.Modifier;

/**
 * 使用JavaPoet写一个Hello 2017/4/24 11:01
 */
public class PoetHello {

    /**
     * 生成器 2017/4/24 14:49
     */
    public static void product() {
        try {

            // 创建方法 2017/4/24 14:26
            MethodSpec method = MethodSpec.methodBuilder("hello")
                    .addModifiers(Modifier.PUBLIC) // 修饰符
                    .returns(String.class) // 返回类型
                    .addParameter(String.class, "name", Modifier.FINAL) // 添加final参数 2017/4/25 09:03
                    .addStatement("String say") // 负责分号、换行 2017/4/24 14:52
                    .addStatement("say = $S + name", "Hello ")
                    .addStatement("return say")
                    .build();

            // 抽象方法 2017/4/24 17:03
            MethodSpec abstractMethod = MethodSpec.methodBuilder("abstractHello")
                    .addModifiers(Modifier.ABSTRACT, Modifier.PROTECTED)
                    .build();

            // 创建类
            TypeSpec hello = TypeSpec.classBuilder("Hello")
                    .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
                    .addMethod(method) // 添加方法
                    .addMethod(abstractMethod)
                    .build();

            // 写入文件系统 2017/4/24 14:27
            JavaFile javaFile = JavaFile.builder("com.example.all_product", hello)
                    .build();

            javaFile.writeTo(new File("poet/src/main/java")); // 指定文件路径
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        PoetHello.product();
    }

}

生成的Hello.java类，代码如下：

package com.example.all_product;

import java.lang.String;

public abstract class Hello {
  public String hello(String name) {
    String say;
    say = "Hello " + name;
    return say;
  }

  protected abstract void abstractHello();
}

例子2，PoetFor

主要讲的就是beginControlFlow() 、endControlFlow()的配合使用，提供换行符与缩进。以for循环为例子，其它使用方法类似，如if、while、switch等等。。。

其中还有$S、$T、$N、$L的使用，意思分别如下：

$S for Strings

顾名思义，$S代表的是String，将其看成是一个字符创即可。

$T for Types

这里的Type/类型，其实可以简单的理解成我们的Class类即可。

$N for Names

可以理解成引用另一个变量名即可。

$L for Literals

这个刚开始其实是比较不好理解，但场景使用多了就应该慢慢能理解了，在这里其实就可以简单的理解成【Formatter】即可。

PoetFor代码如下(切记看注释)：

package com.example;

import com.squareup.javapoet.FieldSpec;
import com.squareup.javapoet.JavaFile;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.TypeSpec;

import java.io.File;

import javax.lang.model.element.Modifier;

/**
 * 生成for代码 2017/4/24 14:57
 */
public class PoetFor {

    /**
     * for循环生成器 2017/4/24 14:57
     */
    public static void product(int from, int to) {
        try {

            // 创建全局字段，并初始化 2017/4/25 09:15
            FieldSpec fieldSpec = FieldSpec.builder(String.class, "DESC")
                    .addModifiers(Modifier.PRIVATE, Modifier.STATIC, Modifier.FINAL)
                    .initializer("$S", "Sum is ")
                    .build();

            // 生成方法 2017/4/24 15:09
            MethodSpec methodSpec = MethodSpec.methodBuilder("forInteger")
                    .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                    .returns(void.class) // 无返回值
                    .addStatement("int sum = 0")

                    // beginControlFlow() + endControlFlow() 需要一起使用，提供换行符和缩进。 2017/4/24 15:09
                    // $L 占位符，类似于Formatter，替换int类型 2017/4/24 15:25
                    .beginControlFlow("for (int i = $L; i <= $L; i++)", from, to)
                    .addStatement("sum += i")
                    .endControlFlow()

                    // $T 替换类名   $S 替换字符串 2017/4/24 15:31
                    // 使用System会自动import使用 2017/4/24 15:34
                    .addStatement("$T.out.println($N + sum)", System.class, "DESC")
                    .build();

            // 类生成 2017/4/24 15:10
            TypeSpec typeSpec = TypeSpec.classBuilder("ForInteger")
                    .addModifiers(Modifier.PUBLIC)
                    .addMethod(methodSpec)
                    .addField(fieldSpec)
                    .build();

            // 文件生成 2017/4/24 15:10
            JavaFile javaFile = JavaFile.builder("com.example.all_product", typeSpec)
                    .addFileComment("JavaPoet生成For循环代码 2017/4/24 15:07")
                    .build();

            javaFile.writeTo(new File("poet/src/main/java"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        PoetFor.product(0, 10);
    }

}

生成的ForInteger.java类如下：

// JavaPoet生成For循环代码 2017/4/24 15:07
package com.example.all_product;

import java.lang.String;
import java.lang.System;

public class ForInteger {
  private static final String DESC = "Sum is ";

  public static void forInteger() {
    int sum = 0;
    for (int i = 0; i <= 10; i++) {
      sum += i;
    }
    System.out.println(DESC + sum);
  }
}

例子3，PoetList

主要讲的是ClassName的硬指定，以及引用指定；然后再讲了使用ParameterizedTypeName.get(ClassName, ClassName)创建List<Object>泛型的使用。

PoetList的代码如下：

package com.example;

import com.example.all_product.ForInteger;
import com.squareup.javapoet.ClassName;
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 java.io.File;

import javax.lang.model.element.Modifier;

/**
 * 使用ClassName(重要)，生成List代码 2017/4/24 16:04
 */
public class PoetList {

    /**
     * 生成器 2017/4/24 16:04
     */
    public static void product() {
        try {

            // list泛型的类型 2017/4/24 16:06
            ClassName type = ClassName.get("com.example.all_product", "ForInteger");

            // List类型
            ClassName list = ClassName.get("java.util", "List");

            // ArrayList类型
            ClassName arrayList = ClassName.get("java.util", "ArrayList");

            // 生成泛型类型，类型的名称、参数的名称 2017/4/24 16:08
            TypeName listType = ParameterizedTypeName.get(list, type);

            MethodSpec methodSpec = MethodSpec.methodBuilder("listType")
                    .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                    .returns(listType)
                    .addStatement("$T lstHello = new $T<>()", listType, arrayList)

                    // ClassName类的绝对路径，内部利用该路径进行反射获取实体类，使用场景是当该类也是生成类时，可以硬指定 2017/4/24 16:18
                    .addStatement("lstHello.add(new $T())", type) // ClassName指定
                    .addStatement("lstHello.add(new $T())", ForInteger.class) // 引用指定
                    .addStatement("return lstHello")
                    .build();

            TypeSpec typeSpec = TypeSpec.classBuilder("ListType")
                    .addModifiers(Modifier.PUBLIC)
                    .addMethod(methodSpec)
                    .build();

            JavaFile javaFile = JavaFile.builder("com.example.all_product", typeSpec)
                    .build();

            javaFile.writeTo(new File("poet/src/main/java"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        PoetList.product();
    }

}

生成的ListType.java类，代码如下：

package com.example.all_product;

import java.util.ArrayList;
import java.util.List;

public class ListType {
  public static List<ForInteger> listType() {
    List<ForInteger> lstHello = new ArrayList<>();
    lstHello.add(new ForInteger());
    lstHello.add(new ForInteger());
    return lstHello;
  }
}

例子4，PoetMap

上面例子3讲的是List<Object>的使用，那么下面再来讲一下Map<Key, Value>的创建使用。

PoetMap的代码如下：

package com.example;

import com.squareup.javapoet.ClassName;
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 java.io.File;

import javax.lang.model.element.Modifier;

/**
 * 使用ClassName(重要)，生成Map代码 2017/4/25 13:39
 */
public class PoetMap {

    /**
     * 生成器 2017/4/25 13:39
     */
    public static void product() {
        try {

            // list泛型的类型 2017/4/24 16:06
            ClassName type = ClassName.get("com.example.all_product", "ForInteger");

            // key 2017/4/25 13:38
            ClassName string = ClassName.get("java.land", "String");

            // map类型
            ClassName map = ClassName.get("java.util", "Map");

            // HashMap类型
            ClassName hashMap = ClassName.get("java.util", "HashMap");

            // 生成Map类型，类型的名称、Key、Value 2017/4/25 14:08
            TypeName listType = ParameterizedTypeName.get(map, string, type);

            MethodSpec methodSpec = MethodSpec.methodBuilder("listType")
                    .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
                    .returns(listType)
                    .addStatement("$T mapHello = new $T<>()", listType, hashMap)
                    .addStatement("mapHello.put($S, new $T())", "key", type)
                    .addStatement("return mapHello")
                    .build();

            TypeSpec typeSpec = TypeSpec.classBuilder("MapType")
                    .addModifiers(Modifier.PUBLIC)
                    .addMethod(methodSpec)
                    .build();

            JavaFile javaFile = JavaFile.builder("com.example.all_product", typeSpec)
                    .build();

            javaFile.writeTo(new File("poet/src/main/java"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        PoetMap.product();
    }

}

生成的MapType.java，代码如下：

package com.example.all_product;

import java.util.HashMap;
import java.util.Map;

public class MapType {
  public static Map<String, ForInteger> listType() {
    Map<String, ForInteger> mapHello = new HashMap<>();
    mapHello.put("key", new ForInteger());
    return mapHello;
  }
}

例子5，PoetInterface

该例子讲的是利用JavaPoet来生成接口，使用的是TypeSpec.interfaceBuilder(InterfaceName)方法来创建接口类，也可以使用TypeSpec中的其它方法来创建枚举、注解等等。。。

PoetInterface的代码如下：

package com.example;

import com.squareup.javapoet.FieldSpec;
import com.squareup.javapoet.JavaFile;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.TypeSpec;

import java.io.File;

import javax.lang.model.element.Modifier;

/**
 * 生成接口 2017/4/25 09:16
 */
public class PoetInterface {

    /**
     * 生成器 2017/4/25 09:40
     */
    public static void product() {

        try {

            // 生成方法，必须有Modifier.ABSTRACT或STATIC 2017/4/25 09:25
            MethodSpec methodSpec = MethodSpec.methodBuilder("getName")
                    .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
                    .addJavadoc("获取名称\n") // 添加注释 2017/4/25 11:24
                    .returns(String.class)
                    .build();

            // 生成字段，必须同时有Modifier.STATIC, Modifier.FINAL 2017/4/25 09:31
            FieldSpec fieldSpec = FieldSpec.builder(String.class, "name")
                    .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
                    .initializer("$S", "CCB")
                    .build();

            // interfaceBuilder方法标志生成接口类 2017/4/25 09:25
            TypeSpec typeSpec = TypeSpec.interfaceBuilder("UserInterface")
                    .addModifiers(Modifier.PUBLIC)
                    .addMethod(methodSpec)
                    .addField(fieldSpec)
                    .build();

            // 写入文件
            JavaFile javaFile = JavaFile.builder("com.example.all_product", typeSpec)
                    .addFileComment("Poet生成接口 2017/4/25 09:24")
                    .build();

            javaFile.writeTo(new File("poet/src/main/java"));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        PoetInterface.product();
    }

}

生成的UserInterface.java接口类，代码如下：

// Poet生成接口 2017/4/25 09:24
package com.example.all_product;

import java.lang.String;

public interface UserInterface {
  String name = "CCB";

  /**
   * 获取名称
   */
  String getName();
}

例子6，PoetSort

主要讲的就是怎么创建匿名类。该例子先自动创建一个实体，再引用该实体类做sort排序。

PoetSort的代码如下：

package com.example;

import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.FieldSpec;
import com.squareup.javapoet.JavaFile;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.ParameterizedTypeName;
import com.squareup.javapoet.TypeSpec;

import java.io.File;
import java.util.Collections;

import javax.lang.model.element.Modifier;

/**
 * 写匿名类进行排序 2017/4/25 09:39
 */
public class PoetSort {

    public static void product() {
        try {

            // 生成实体 2017/4/25 09:41
            TypeSpec typeEntity = TypeSpec.classBuilder("UserEntity")
                    .addModifiers(Modifier.PUBLIC)
                    .addField(FieldSpec.builder(String.class, "name")
                            .addModifiers(Modifier.PRIVATE)
                            .build())
                    .addMethod(MethodSpec.methodBuilder("getName")
                            .addModifiers(Modifier.PUBLIC)
                            .returns(String.class)
                            .addStatement("return this.$N", "name")
                            .build())
                    .addMethod(MethodSpec.methodBuilder("setName")
                            .addModifiers(Modifier.PUBLIC)
                            .addParameter(String.class, "name")
                            .returns(void.class)
                            .addStatement("this.$N = $N", "name", "name")
                            .build())
                    .addField(FieldSpec.builder(int.class, "time")
                            .addModifiers(Modifier.PRIVATE)
                            .build())
                    .addMethod(MethodSpec.methodBuilder("getTime")
                            .addModifiers(Modifier.PUBLIC)
                            .returns(int.class)
                            .addStatement("return this.$N", "time")
                            .build())
                    .build();

            // 写入用户实体 2017/4/25 09:48
            JavaFile javaUserEntity = JavaFile.builder("com.example.all_product", typeEntity)
                    .build();

            javaUserEntity.writeTo(new File("poet/src/main/java"));

            // 生成排序匿名类 2017/4/25 09:49
            ClassName classComparator = ClassName.get("java.util", "Comparator"); // 指向Comparator
            ClassName classList = ClassName.get("java.util", "List"); // 指向List
            ClassName classUser = ClassName.get("com.example.all_product", "UserEntity"); // 指向User实体

            // 匿名比对类 2017/4/25 09:52
            TypeSpec typeCompare = TypeSpec.anonymousClassBuilder("")
                    .addSuperinterface(ParameterizedTypeName.get(classComparator, classUser))
                    .addMethod(MethodSpec.methodBuilder("compare")
                            .addAnnotation(Override.class) // 添加注解 2017/4/25 10:56
                            .addModifiers(Modifier.PUBLIC)
                            .addParameter(classUser, "obj1")
                            .addParameter(classUser, "obj2")
                            .returns(int.class)
                            .beginControlFlow("if ($N.$N() > $N.$N())",
                                    "obj1", "getTime", "obj2", "getTime")
                            .addStatement("return 1")
                            .endControlFlow()
                            .beginControlFlow("else if ($N.$N() < $N.$N())",
                                    "obj1", "getTime", "obj2", "getTime")
                            .addStatement("return -1")
                            .endControlFlow()
                            .beginControlFlow("else")
                            .addStatement("return 0")
                            .endControlFlow()
                            .build())
                    .build();

            // 外部类 2017/4/25 09:59
            TypeSpec typeSort = TypeSpec.classBuilder("UserSort")
                    .addModifiers(Modifier.PUBLIC)
                    .addMethod(MethodSpec.methodBuilder("sort")
                            .addModifiers(Modifier.PUBLIC)
                            .returns(void.class)
                            .addParameter(ParameterizedTypeName.get(classList, classUser), "lstUsers")
                            .addStatement("$T.sort($N, $L)", Collections.class, "lstUsers", typeCompare)
                            .build())
                    .build();

            // 写入排序类 2017/4/25 10:03
            JavaFile javaUserSort = JavaFile.builder("com.example.all_product", typeSort)
                    .build();

            javaUserSort.writeTo(new File("poet/src/main/java"));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        PoetSort.product();
    }

}

生成的UserEntity.java和UserSort.java类的代码如下：

package com.example.all_product;

import java.lang.String;

public class UserEntity {
  private String name;

  private int time;

  public String getName() {
    return this.name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getTime() {
    return this.time;
  }
}

package com.example.all_product;

import java.lang.Override;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class UserSort {
  public void sort(List<UserEntity> lstUsers) {
    Collections.sort(lstUsers, new Comparator<UserEntity>() {
      @Override
      public int compare(UserEntity obj1, UserEntity obj2) {
        if (obj1.getTime() > obj2.getTime()) {
          return 1;
        }
        else if (obj1.getTime() < obj2.getTime()) {
          return -1;
        }
        else {
          return 0;
        }
      }
    });
  }
}

例子7，PoetExtend

主要就讲一下怎么使用superclass(ClassName)的方法来创建继承的子类，同理，也可以使用addSuperinterface(ClassName)的方法来创建实现接口，实现接口后，怎么重写接口的方法，可参考例子5。。。

PoetExtend的代码如下：

package com.example;

import com.squareup.javapoet.ClassName;
import com.squareup.javapoet.FieldSpec;
import com.squareup.javapoet.JavaFile;
import com.squareup.javapoet.MethodSpec;
import com.squareup.javapoet.TypeSpec;

import java.io.File;

import javax.lang.model.element.Modifier;

/**
 * 生成继承的子类 2017/4/25 14:48
 */
public class PoetExtend {

    public static void product() {
        try {

            // 生成实体 2017/4/25 14:48
            TypeSpec typeEntity = TypeSpec.classBuilder("SubUserEntity")
                    .addModifiers(Modifier.PUBLIC)

                    // 继承UserEntity类 2017/4/25 14:58
                    .superclass(ClassName.get("com.example.all_product", "UserEntity"))

                    // 实现UserInterface接口
                    .addSuperinterface(ClassName.get("com.example.all_product", "UserInterface"))
                    .addField(FieldSpec.builder(int.class, "id")
                            .addModifiers(Modifier.PRIVATE)
                            .build())
                    .addMethod(MethodSpec.methodBuilder("getId")
                            .addModifiers(Modifier.PUBLIC)
                            .returns(int.class)
                            .addStatement("return this.$N", "id")
                            .build())
                    .build();

            // 写入用户实体 2017/4/25 14:55
            JavaFile javaUserEntity = JavaFile.builder("com.example.all_product", typeEntity)
                    .build();

            javaUserEntity.writeTo(new File("poet/src/main/java"));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        PoetExtend.product();
    }

}

生成的SubUserEntity代码如下：

package com.example.all_product;

public class SubUserEntity extends UserEntity implements UserInterface {
  private int id;

  public int getId() {
    return this.id;
  }
}

总结

怎么动态的生成java代码，我们今天主要讲7个例子就好了，在我们写项目时，如果需要动态生成代码时，这应该足够应付80%的开发工作了，如果需要深入创建更复杂的代码，请移步参考JavaPoet开源框架。

结合前面几篇文章，就已经包含了创建注解、注解解析、代码生成，慢慢。。。慢慢。。。我们向自己写框架靠近。。。其实框架中经常使用的还有另一个检查工具，lint。我们可以自定义lint的检查规则，不过，我现在有一个地方卡住了，还没解决，后面如果解决了，有机会就一并讲一下。

今天就讲到这里了。。。

谢谢支持~~~