当前位置:首页 > 开发教程 > 手机开发 >

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

时间:2016-09-27 09:52 来源:互联网 作者:源码搜藏 浏览: 收藏 挑错 推荐 打印

JavaPoet 是用于产生一个Java API 的.java 源文件。 做事情时,如注释处理或元数据文件(例如,数据库架构,协议格式)的交互源文件的生成可能是有用的。 通过生成的代码,你无需编写样板,同时也保持真实性单一来源的元数据。 例 这里有一个(无聊) 的Hell

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'

相关文章
JavaPoet动态生成java文件源码初探

android开发中的JavaPoet(一种Java API生成.java源文件)转载https://www.codesocang.com/jiaocheng/shoujikaifa/28544.html

手机开发阅读排行

最新文章