android开发中的JavaPoet（一种Java API生成.java源文件）

JavaPoet是用于产生一个Java API 的.java源文件。

做事情时，如注释处理或元数据文件（例如，数据库架构，协议格式）的交互安卓源码文件的生成可能是有用的。通过生成的代码，你无需编写样板，同时也保持真实性单一来源的元数据。

例

这里有一个（无聊）的HelloWorld类：

package com.example.helloworld;

public final class HelloWorld {
  public static void main(String[] args) {
    System.out.println("Hello, JavaPoet!");
  }
}

这就是（励磁）码与JavaPoet生成它：

MethodSpec main = MethodSpec.methodBuilder("main")
    .addModifiers(Modifier.PUBLIC, Modifier.STATIC)
    .returns(void.class)
    .addParameter(String[].class, "args")
    .addStatement("$T.out.println($S)", System.class, "Hello, JavaPoet!")
    .build();

TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
    .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
    .addMethod(main)
    .build();

JavaFile javaFile = JavaFile.builder("com.example.helloworld", helloWorld)
    .build();

javaFile.writeTo(System.out);

要声明的主要方法，我们已经创建了一个MethodSpec “主”配置修饰符，返回类型，参数和代码语句。我们的主要方法添加到的HelloWorld类，然后添加到HelloWorld.java文件。

在这种情况下，我们将文件写入System.out的，但我们也可以把它作为一个字符串（JavaFile.toString（） ），或将其写入到文件系统（JavaPoet.writeTo（） ）。

该Javadoc中编目完成JavaPoet API，我们将在下面探讨。

代码和控制流

大多数JavaPoet API的使用普通的旧不变的Java对象。还有建筑商，方法链接和可变参数，使API友好。JavaPoet提供模型类和接口（TypeSpec），场（的FieldSpec），方法和构造函数（MethodSpec），参数（ParameterSpec）和说明（AnnotationSpec）。

但体的方法和构造不建模。有没有表达类，没有语句类或语法树的节点。相反，JavaPoet使用码块字符串：

MethodSpec main = MethodSpec.methodBuilder("main")
    .addCode(""
        + "int total = 0;\n"
        + "for (int i = 0; i < 10; i++) {\n"
        + "  total += i;\n"
        + "}\n")
    .build();

产生这样的：

void main() {
  int total = 0;
  for (int i = 0; i < 10; i++) {
    total += i;
  }
}

手动分号，换行和缩进繁琐等JavaPoet提供的API，使其更容易。有addStatement（）这需要分号和换行符的照顾，和beginControlFlow（） + endControlFlow（）这对大括号，换行符一起使用，和缩进：

MethodSpec main = MethodSpec.methodBuilder("main")
    .addStatement("int total = 0")
    .beginControlFlow("for (int i = 0; i < 10; i++)")
    .addStatement("total += i")
    .endControlFlow()
    .build();

这个例子是跛，因为生成的代码是不变的！假设，而不是仅仅将0到10，我们想使操作和范围配置。下面是生成方法的方法：

private MethodSpec computeRange(String name, int from, int to, String op) {
  return MethodSpec.methodBuilder(name)
      .returns(int.class)
      .addStatement("int result = 0")
      .beginControlFlow("for (int i = " + from + "; i < " + to + "; i++)")
      .addStatement("result = result " + op + " i")
      .endControlFlow()
      .addStatement("return result")
      .build();
}

这里就是我们得到当我们调用computeRange（“multiply10to20”，10，20，“*”） ：

int multiply10to20() {
  int result = 0;
  for (int i = 10; i < 20; i++) {
    result = result * i;
  }
  return result;
}

方法产生的办法！而且，由于JavaPoet产生的，而不是字节码源，您可以通过它读取，以确保它是正确的。

$ L的字面

字串串联在调用beginControlFlow（）和addStatement是分心。太多的运营商。为了解决这个问题，JavaPoet提供了一个语法的启发，由不兼容，但是，用 的String.format（） 。它接受$ L发出一个字面的产值。这个工作就像格式化的％S：

private MethodSpec computeRange(String name, int from, int to, String op) {
  return MethodSpec.methodBuilder(name)
      .returns(int.class)
      .addStatement("int result = 0")
      .beginControlFlow("for (int i = $L; i < $L; i++)", from, to)
      .addStatement("result = result $L i", op)
      .endControlFlow()
      .addStatement("return result")
      .build();
}

文字被直接排放到没有逃逸输出代码。对于文本参数可以是字符串，基元，并描述如下几个JavaPoet类型。

$ S弦乐

当发光代码，包括字符串，我们可以用$ S发出一个字符串，完整的包装引号和逃避。下面是发出3种方法，每一个返回自己的名字的程序：

public static void main(String[] args) throws Exception {
  TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
      .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
      .addMethod(whatsMyName("slimShady"))
      .addMethod(whatsMyName("eminem"))
      .addMethod(whatsMyName("marshallMathers"))
      .build();

  JavaFile javaFile = JavaFile.builder("com.example.helloworld", helloWorld)
      .build();

  javaFile.writeTo(System.out);
}

private static MethodSpec whatsMyName(String name) {
  return MethodSpec.methodBuilder(name)
      .returns(String.class)
      .addStatement("return $S", name)
      .build();
}

在这种情况下，使用$ S为我们提供了引号：

public final class HelloWorld {
  String slimShady() {
    return "slimShady";
  }

  String eminem() {
    return "eminem";
  }

  String marshallMathers() {
    return "marshallMathers";
  }
}

为类型$ T

我们Java程序员爱我们的类型：他们让我们的代码更容易理解。而JavaPoet在船上。它有类型丰富的内置支持，包括自动生成的导入 语句。只需用$ T引用类型：

MethodSpec today = MethodSpec.methodBuilder("today")
    .returns(Date.class)
    .addStatement("return new $T()", Date.class)
    .build();

TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
    .addModifiers(Modifier.PUBLIC, Modifier.FINAL)
    .addMethod(today)
    .build();

JavaFile javaFile = JavaFile.builder("com.example.helloworld", helloWorld)
    .build();

javaFile.writeTo(System.out);

这会产生以下的.java文件，完成必要的进口：

package com.example.helloworld;

import java.util.Date;

public final class HelloWorld {
  Date today() {
    return new Date();
  }
}

我们通过Date.class引用的一类，只是那么恰好是可用的，当我们生成代码。这并不需要是这种情况。这里有一个类似的例子，但是这一次引用不存在（还）类：

ClassName hoverboard = ClassName.get("com.mattel", "Hoverboard");

MethodSpec today = MethodSpec.methodBuilder("tomorrow")
    .returns(hoverboard)
    .addStatement("return new $T()", hoverboard)
    .build();

而这还未存在的类的进口，以及：

package com.example.helloworld;

import com.mattel.Hoverboard;

public final class HelloWorld {
  Hoverboard tomorrow() {
    return new Hoverboard();
  }
}

在类名的类型是非常重要的，当你使用JavaPoet你需要它频繁。它可以识别任何声明类。声明的类型是Java的丰富的类型系统仅仅是个开始：我们也有数组，参数化类型，通配符类型和类型变量。JavaPoet对每个建设的这些类：

ClassName hoverboard = ClassName.get("com.mattel", "Hoverboard");
ClassName list = ClassName.get("java.util", "List");
ClassName arrayList = ClassName.get("java.util", "ArrayList");
TypeName listOfHoverboards = ParameterizedTypeName.get(list, hoverboard);

MethodSpec beyond = MethodSpec.methodBuilder("beyond")
    .returns(listOfHoverboards)
    .addStatement("$T result = new $T<>()", listOfHoverboards, arrayList)
    .addStatement("result.add(new $T())", hoverboard)
    .addStatement("result.add(new $T())", hoverboard)
    .addStatement("result.add(new $T())", hoverboard)
    .addStatement("return result")
    .build();

JavaPoet会分解每一种类型，并在可能的情况导入其组件。

package com.example.helloworld;

import com.mattel.Hoverboard;
import java.util.ArrayList;
import java.util.List;

public final class HelloWorld {
  List<Hoverboard> beyond() {
    List<Hoverboard> result = new ArrayList<>();
    result.add(new Hoverboard());
    result.add(new Hoverboard());
    result.add(new Hoverboard());
    return result;
  }
}

静态导入

JavaPoet支持进口静电。它做它通过明确收集类型成员的名称。让我们加强与一些静态糖前面的例子：

...
ClassName namedBoards = ClassName.get("com.mattel", "Hoverboard", "Boards");

MethodSpec beyond = MethodSpec.methodBuilder("beyond")
    .returns(listOfHoverboards)
    .addStatement("$T result = new $T<>()", listOfHoverboards, arrayList)
    .addStatement("result.add($T.createNimbus(2000))", hoverboard)
    .addStatement("result.add($T.createNimbus(\"2001\"))", hoverboard)
    .addStatement("result.add($T.createNimbus($T.THUNDERBOLT))", namedBoards)
    .addStatement("$T.sort(result)", Collections.class)
    .addStatement("return result.isEmpty() $T.emptyList() : result", Collections.class)
    .build();

TypeSpec hello = TypeSpec.classBuilder("HelloWorld")
    .addMethod(beyond)
    .build();

JavaFile.builder("com.example.helloworld", hello)
    .addStaticImport(hoverboard, "createNimbus")
    .addStaticImport(namedBoards, "*")
    .addStaticImport(Collections.class, "*")
    .build();

JavaPoet将首先你增加进口静态块到文件配置，匹配，并相应裂伤所有来电，还需要导入所有其他类型。

package com.example.helloworld;

import static com.mattel.Hoverboard.Boards.*;
import static com.mattel.Hoverboard.createNimbus;
import static java.util.Collections.*;

import com.mattel.Hoverboard;
import java.util.ArrayList;
import java.util.List;

class HelloWorld {
  List<Hoverboard> beyond() {
    List<Hoverboard> result = new ArrayList<>();
    result.add(createNimbus(2000));
    result.add(createNimbus("2001"));
    result.add(createNimbus(THUNDERBOLT));
    sort(result);
    return result.isEmpty()  emptyList() : result;
  }
}

$ N的名称

生成的代码往往是自我指涉。使用$ N由它的名称引用另一个生成的声明。下面是调用另一个方法：

public String byteToHex(int b) {
  char[] result = new char[2];
  result[0] = hexDigit((b >>> 4) & 0xf);
  result[1] = hexDigit(b & 0xf);
  return new String(result);
}

public char hexDigit(int i) {
  return (char) (i < 10  i + '0' : i - 10 + 'a');
}

当生成上面的代码中，我们通过hexDigit（）方法作为参数传递给byteToHex（） 的使用方法$ N：

MethodSpec hexDigit = MethodSpec.methodBuilder("hexDigit")
    .addParameter(int.class, "i")
    .returns(char.class)
    .addStatement("return (char) (i < 10  i + '0' : i - 10 + 'a')")
    .build();

MethodSpec byteToHex = MethodSpec.methodBuilder("byteToHex")
    .addParameter(int.class, "b")
    .returns(String.class)
    .addStatement("char[] result = new char[2]")
    .addStatement("result[0] = $N((b >>> 4) & 0xf)", hexDigit)
    .addStatement("result[1] = $N(b & 0xf)", hexDigit)
    .addStatement("return new String(result)")
    .build();

方法

所有上述方法具有代码本体。使用Modifiers.ABSTRACT获得方法没有任何的身体。这是唯一合法的，如果封闭类可以是抽象或接口。

MethodSpec flux = MethodSpec.methodBuilder("flux")
    .addModifiers(Modifier.ABSTRACT, Modifier.PROTECTED)
    .build();

TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
    .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
    .addMethod(flux)
    .build();

产生这样的：

public abstract class HelloWorld {
  protected abstract void flux();
}

其他修饰符在哪里工作许可。注意，指定修饰符时，JavaPoet使用 javax.lang.model.element.Modifier，一类是不可用在Android上。这种限制仅适用于代码生成代码; 输出代码运行无处不在：JVM上，Android和GWT。

方法也有参数，异常可变参数，Javadoc中，注释，类型变量和返回类型。所有这些都配置MethodSpec.Builder。

构造函数

MethodSpec轻微的用词不当; 它也可以用于构造：

MethodSpec flux = MethodSpec.constructorBuilder()
    .addModifiers(Modifier.PUBLIC)
    .addParameter(String.class, "greeting")
    .addStatement("this.$N = $N", "greeting", "greeting")
    .build();

TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
    .addModifiers(Modifier.PUBLIC)
    .addField(String.class, "greeting", Modifier.PRIVATE, Modifier.FINAL)
    .addMethod(flux)
    .build();

产生这样的：

public class HelloWorld {
  private final String greeting;

  public HelloWorld(String greeting) {
    this.greeting = greeting;
  }
}

在大多数情况下，构造函数的工作就像方法。当发光代码，JavaPoet将在输出文件方法之前放置构造函数。

参数

声明与任一方法和构造函数的参数ParameterSpec.builder（）或 MethodSpec的方便addParameter）（ API：

ParameterSpec android = ParameterSpec.builder(String.class, "android")
    .addModifiers(Modifier.FINAL)
    .build();

MethodSpec welcomeOverlords = MethodSpec.methodBuilder("welcomeOverlords")
    .addParameter(android)
    .addParameter(String.class, "robot", Modifier.FINAL)
    .build();

虽然上面的代码来生成机器人和机器人参数是不同的，在输出是相同的：

void welcomeOverlords(final String android, final String robot) {
}

扩展生成器的形式是必要的，当参数有注释（如@Nullable）。

字段

像参数，字段可以与制造商或使用便捷的辅助方法来创建：

FieldSpec android = FieldSpec.builder(String.class, "android")
    .addModifiers(Modifier.PRIVATE, Modifier.FINAL)
    .build();

TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
    .addModifiers(Modifier.PUBLIC)
    .addField(android)
    .addField(String.class, "robot", Modifier.PRIVATE, Modifier.FINAL)
    .build();

产生：

public class HelloWorld {
  private final String android;

  private final String robot;
}

扩展生成器的形式是必要的，当现场有Javadoc中，注释，或字段初始化。字段初始使用相同的String.format（）式的语法上面的代码块：

FieldSpec android = FieldSpec.builder(String.class, "android")
    .addModifiers(Modifier.PRIVATE, Modifier.FINAL)
    .initializer("$S + $L", "Lollipop v.", 5.0d)
    .build();

产生：

private final String android = "Lollipop v." + 5.0;

接口

JavaPoet与接口没有麻烦。需要注意的是接口方法必须始终PUBLIC摘要和接口字段必须始终为公共静态最后。定义接口时，这些修饰符是必要的：

TypeSpec helloWorld = TypeSpec.interfaceBuilder("HelloWorld")
    .addModifiers(Modifier.PUBLIC)
    .addField(FieldSpec.builder(String.class, "ONLY_THING_THAT_IS_CONSTANT")
        .addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
        .initializer("$S", "change")
        .build())
    .addMethod(MethodSpec.methodBuilder("beep")
        .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
        .build())
    .build();

但是生成的代码时，这些改性剂被删去。这些都是缺省值，所以我们并不需要包括他们的javac的利益！

public interface HelloWorld {
  String ONLY_THING_THAT_IS_CONSTANT = "change";

  void beep();
}

枚举

使用enumBuilder创建枚举类型，addEnumConstant（）为每个值：

TypeSpec helloWorld = TypeSpec.enumBuilder("Roshambo")
    .addModifiers(Modifier.PUBLIC)
    .addEnumConstant("ROCK")
    .addEnumConstant("SCISSORS")
    .addEnumConstant("PAPER")
    .build();

为了产生这样的：

public enum Roshambo {
  ROCK,

  SCISSORS,

  PAPER
}

花式枚举的支持，在这里枚举值覆盖的方法或调用父类的构造函数。这里有一个完整的例子：

TypeSpec helloWorld = TypeSpec.enumBuilder("Roshambo")
    .addModifiers(Modifier.PUBLIC)
    .addEnumConstant("ROCK", TypeSpec.anonymousClassBuilder("$S", "fist")
        .addMethod(MethodSpec.methodBuilder("toString")
            .addAnnotation(Override.class)
            .addModifiers(Modifier.PUBLIC)
            .addStatement("return $S", "avalanche!")
            .build())
        .build())
    .addEnumConstant("SCISSORS", TypeSpec.anonymousClassBuilder("$S", "peace")
        .build())
    .addEnumConstant("PAPER", TypeSpec.anonymousClassBuilder("$S", "flat")
        .build())
    .addField(String.class, "handsign", Modifier.PRIVATE, Modifier.FINAL)
    .addMethod(MethodSpec.constructorBuilder()
        .addParameter(String.class, "handsign")
        .addStatement("this.$N = $N", "handsign", "handsign")
        .build())
    .build();

产生这样的：

public enum Roshambo {
  ROCK("fist") {
    @Override
    public void toString() {
      return "avalanche!";
    }
  },

  SCISSORS("peace"),

  PAPER("flat");

  private final String handsign;

  Roshambo(String handsign) {
    this.handsign = handsign;
  }
}

匿名内部类

在枚举代码中，我们使用Types.anonymousInnerClass（） 。匿名内部类也可以在码块使用。它们是可以与被引用的值$ L：

TypeSpec comparator = TypeSpec.anonymousClassBuilder("")
    .addSuperinterface(ParameterizedTypeName.get(Comparator.class, String.class))
    .addMethod(MethodSpec.methodBuilder("compare")
        .addAnnotation(Override.class)
        .addModifiers(Modifier.PUBLIC)
        .addParameter(String.class, "a")
        .addParameter(String.class, "b")
        .returns(int.class)
        .addStatement("return $N.length() - $N.length()", "a", "b")
        .build())
    .build();

TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
    .addMethod(MethodSpec.methodBuilder("sortByLength")
        .addParameter(ParameterizedTypeName.get(List.class, String.class), "strings")
        .addStatement("$T.sort($N, $L)", Collections.class, "strings", comparator)
        .build())
    .build();

此生成包含包含方法的类中的方法：

void sortByLength(List<String> strings) {
  Collections.sort(strings, new Comparator<String>() {
    @Override
    public int compare(String a, String b) {
      return a.length() - b.length();
    }
  });
}

定义匿名内部类的一个特别棘手的部分是参数父类的构造。在上面的代码中我们传递了不带参数的空字符串：TypeSpec.anonymousClassBuilder（“”） 。要通过不同的参数使用JavaPoet的代码块语法用逗号分隔参数。

注释

简单的注释很简单：

MethodSpec toString = MethodSpec.methodBuilder("toString")
    .addAnnotation(Override.class)
    .returns(String.class)
    .addModifiers(Modifier.PUBLIC)
    .addStatement("return $S", "Hoverboard")
    .build();

产生这种方法具有@Override注释：

  @Override
  public String toString() {
    return "Hoverboard";
  }

使用AnnotationSpec.builder（）上的注释设置属性：

MethodSpec logRecord = MethodSpec.methodBuilder("recordEvent")
    .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
    .addAnnotation(AnnotationSpec.builder(Headers.class)
        .addMember("accept", "$S", "application/json; charset=utf-8")
        .addMember("userAgent", "$S", "Square Cash")
        .build())
    .addParameter(LogRecord.class, "logRecord")
    .returns(LogReceipt.class)
    .build();

产生这个注释与接受和的userAgent属性：

@Headers(
    accept = "application/json; charset=utf-8",
    userAgent = "Square Cash"
)
LogReceipt recordEvent(LogRecord logRecord);

当你看中了，标注值可以标注自己。使用$ L为嵌入式注释：

MethodSpec logRecord = MethodSpec.methodBuilder("recordEvent")
    .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
    .addAnnotation(AnnotationSpec.builder(HeaderList.class)
        .addMember("value", "$L", AnnotationSpec.builder(Header.class)
            .addMember("name", "$S", "Accept")
            .addMember("value", "$S", "application/json; charset=utf-8")
            .build())
        .addMember("value", "$L", AnnotationSpec.builder(Header.class)
            .addMember("name", "$S", "User-Agent")
            .addMember("value", "$S", "Square Cash")
            .build())
        .build())
    .addParameter(LogRecord.class, "logRecord")
    .returns(LogReceipt.class)
    .build();

产生这样的：

@HeaderList({
    @Header(name = "Accept", value = "application/json; charset=utf-8"),
    @Header(name = "User-Agent", value = "Square Cash")
})
LogReceipt recordEvent(LogRecord logRecord);

请注意，您可以调用使用addMember（）具有相同的属性名称多次来填充该属性值的列表。

的Javadoc

字段，方法和类型可以用的Javadoc被记录：

MethodSpec dismiss = MethodSpec.methodBuilder("dismiss")
    .addJavadoc("Hides {@code message} from the caller's history. Other\n"
        + "participants in the conversation will continue to see the\n"
        + "message in their own history unless they also delete it.\n")
    .addJavadoc("\n")
    .addJavadoc("<p>Use {@link #delete($T)} to delete the entire\n"
        + "conversation for all participants.\n", Conversation.class)
    .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
    .addParameter(Message.class, "message")
    .build();

产生这样的：

  /**
   * Hides {@code message} from the caller's history. Other
   * participants in the conversation will continue to see the
   * message in their own history unless they also delete it.
   *
   * <p>Use {@link #delete(Conversation)} to delete the entire
   * conversation for all participants.
   */
  void dismiss(Message message);

使用$ T时的Javadoc引用类型得到自动进口。

下载

下载最新的.jar或通过Maven的依赖：

<dependency>
  <groupId>com.squareup</groupId>
  <artifactId>javapoet</artifactId>
  <version>1.5.1</version>
</dependency>

或摇篮：

compile 'com.squareup:javapoet:1.5.1'

源码搜藏网

首页 > 开发教程 > 手机开发 >