Annotation Processing at GDG taipei 2019

1. Annotation
Processing
Tim

2. About me
Tim / Jintin
Android / iOS developer
Senior Software Engineer
@ Carousell
https://github.com/Jintin
https://medium.com/@Jintin

3. How to write
flawless code?

7. Don’t write ANY code

8. Do write LESS code

9. “Annotation Processing is a tool we
can use to help us generate code in
compile time by labeling Annotations
inside our source code.”

10. Pros & Cons
+ Less boilerplate code
+ No Runtime Error
- Block incremental build
- Kotlin 1.3.30+
- Gradle 4.7+
- Compile overhead

11. One more thing…

12. One more inch…

13. How does Annotation
Processing work?

14. How we use it
dependencies {
implementation 'com.google.dagger:dagger:2.x'
kapt ‘com.google.dagger:dagger-compiler:2.x'
}
kapt stands for
Kotlin annotation processing tool

15. Module structure
Library module (optional)
Processor(compiler) module
Annotation module

16. Annotation

17. Annotation
Attributes
Targets
Retention

18. Attribute
@GET(“XXX_Value")
Observable getAPI();
@Component(modules = {
AModule.class,
BModule.class,
CModule.class})
public interface MyComponent {}

19. Attribute
@Target(METHOD)
@Retention(RUNTIME)
public @interface GET {
String value() default "";
}
@Retention(RUNTIME)
@Target(TYPE)
public @interface Component {
Class<?>[] modules() default {};
Class<?>[] dependencies() default {};
}

20. Attribute
Primitive types (int, long, etc.)
String
Classes (Foo::class)
Enums
Other annotations
Arrays of the types listed above.

21. Annotation
Attributes
Targets
Retention

22. Target
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD,
LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER,
TYPE})
public @interface Deprecated {}

23. Annotation
Attributes
Targets
Retention

24. Retention
@Target(ElementType.METHOD)
@Retention(SOURCE)
public @interface Override {}
@Target({ METHOD, CONSTRUCTOR, FIELD })
@Retention(RUNTIME)
public @interface Inject {}

25. Retention
public enum RetentionPolicy {
/* only exist before compile finish. */
SOURCE,
/* recorded in the class file by the compiler but need not
be retained by the VM at run time. */
CLASS,
/* to be recorded in the class file and can be used at run
time, so they may be read reflectively. */
RUNTIME
}

26. Retention
public enum RetentionPolicy {
/* only exist before compile finish. */
SOURCE,
/* recorded in the class file by the compiler but need not
be retained by the VM at run time. */
CLASS,
/* to be recorded in the class file and can be used at run
time, so they may be read reflectively. */
RUNTIME
}

27. Retention
public enum RetentionPolicy {
/* only exist before compile finish. */
SOURCE,
/* recorded in the class file by the compiler but need not
be retained by the VM at run time. */
CLASS,
/* to be recorded in the class file and can be used at run
time, so they may be read reflectively. */
RUNTIME
}

28. Retention
public enum RetentionPolicy {
/* only exist before compile finish. */
SOURCE,
/* recorded in the class file by the compiler but need not
be retained by the VM at run time. */
CLASS,
/* to be recorded in the class file and can be used at run
time, so they may be read reflectively. */
RUNTIME
}

29. Processor module
Only used in compile phase.
Not include in final Jar/Apk.
Can contain several Processors.

30. Hook

31. AutoService Hook
@AutoService(Processor::class)
class AdapterProcessor : Processor()
dependencies {
implementation ‘com.google.auto.service:auto-service:1.X’
}

32. public interface Processor {
/** Initializes with the processing environment. */
void init(ProcessingEnvironment processingEnv);
/** Returns the target the annotation types to process. */
Set<String> getSupportedAnnotationTypes();
/** Processes a set of annotation on type elements. */
boolean process(Set<? extends TypeElement> set,
RoundEnvironment roundEnv);
…
}
Processor

33. public interface Processor {
/** Initializes with the processing environment. */
void init(ProcessingEnvironment processingEnv);
/** Returns the target the annotation types to process. */
Set<String> getSupportedAnnotationTypes();
/** Processes a set of annotation on type elements. */
boolean process(Set<? extends TypeElement> set,
RoundEnvironment roundEnv);
…
}
Processor

34. public interface Processor {
/** Initializes with the processing environment. */
void init(ProcessingEnvironment processingEnv);
/** Returns the target the annotation types to process. */
Set<String> getSupportedAnnotationTypes();
/** Processes a set of annotation on type elements. */
boolean process(Set<? extends TypeElement> set,
RoundEnvironment roundEnv);
…
}
Processor

35. public interface Processor {
/** Initializes with the processing environment. */
void init(ProcessingEnvironment processingEnv);
/** Returns the target the annotation types to process. */
Set<String> getSupportedAnnotationTypes();
/** Processes a set of annotation on type elements. */
boolean process(Set<? extends TypeElement> set,
RoundEnvironment roundEnv);
…
}
Processor

36. Element
Unit of code element.
- PackageElement: Package
- TypeElement: Class, Interface
- ExecutableElement: Method, Constructor

37. @Override
public boolean process(Set<? extends TypeElement> set,
RoundEnvironment roundEnv) {
for (Element element :
roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
if (element.getKind() != ElementKind.INTERFACE) {
error("Only interface can be used with MyAnnotation", element);
return true;
}
TypeElement typeElement = (TypeElement) element;
typeElement.getInterfaces();
typeElement.getSuperclass();
typeElement.getSimpleName();
MyAnnotation anno = element.getAnnotation(MyAnnotation.class);
/** Custom logic to build the relation graph and generate the file*/
}
return true;
}

38. @Override
public boolean process(Set<? extends TypeElement> set,
RoundEnvironment roundEnv) {
for (Element element :
roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
if (element.getKind() != ElementKind.INTERFACE) {
error("Only interface can be used with MyAnnotation", element);
return true;
}
TypeElement typeElement = (TypeElement) element;
typeElement.getInterfaces();
typeElement.getSuperclass();
typeElement.getSimpleName();
MyAnnotation anno = element.getAnnotation(MyAnnotation.class);
/** Custom logic to build the relation graph and generate the file*/
}
return true;
}

39. @Override
public boolean process(Set<? extends TypeElement> set,
RoundEnvironment roundEnv) {
for (Element element :
roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
if (element.getKind() != ElementKind.INTERFACE) {
error("Only interface can be used with MyAnnotation", element);
return true;
}
TypeElement typeElement = (TypeElement) element;
typeElement.getInterfaces();
typeElement.getSuperclass();
typeElement.getSimpleName();
MyAnnotation anno = element.getAnnotation(MyAnnotation.class);
/** Custom logic to build the relation graph and generate the file*/
}
return true;
}

40. @Override
public boolean process(Set<? extends TypeElement> set,
RoundEnvironment roundEnv) {
for (Element element :
roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
if (element.getKind() != ElementKind.INTERFACE) {
error("Only interface can be used with MyAnnotation", element);
return true;
}
TypeElement typeElement = (TypeElement) element;
typeElement.getInterfaces();
typeElement.getSuperclass();
typeElement.getSimpleName();
MyAnnotation anno = element.getAnnotation(MyAnnotation.class);
/** Custom logic to build the relation graph and generate the file*/
}
return true;
}

41. @Override
public boolean process(Set<? extends TypeElement> set,
RoundEnvironment roundEnv) {
for (Element element :
roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
if (element.getKind() != ElementKind.INTERFACE) {
error("Only interface can be used with MyAnnotation", element);
return true;
}
TypeElement typeElement = (TypeElement) element;
typeElement.getInterfaces();
typeElement.getSuperclass();
typeElement.getSimpleName();
MyAnnotation anno = element.getAnnotation(MyAnnotation.class);
/** Custom logic to build the relation graph and generate the file*/
}
return true;
}

42. How to create file?

43. Filer
Get from ProcessingEnvironment
Generate file under build folder

44. Filer
@Override
public synchronized void init(ProcessingEnvironment env) {
super.init(env);
filer = env.getFiler();
}
@Override
public boolean process(Set<? extends TypeElement> set,
RoundEnvironment roundEnv) {
…
filer.createSourceFile(“NewFile", element);
}

45. How to create code?

46. JavaPoet/KotlinPoet
Provide simple API to generate Java/Kotlin file
Both Square open source projects
Over 8000 stars in total

47. MethodSpec main = MethodSpec.methodBuilder("main")
.build();
JavaPoet

48. MethodSpec main = MethodSpec.methodBuilder("main")
.build();
void main() {
}
JavaPoet

49. MethodSpec main = MethodSpec.methodBuilder("main")
.addParameter(String[].class, "args")
.build();
void main(String[] args) {
}
JavaPoet

50. MethodSpec main = MethodSpec.methodBuilder("main")
.addParameter(String[].class, "args")
.addStatement("$T.out.println($S)", System.class,
"Hello, JavaPoet!")
.build();
void main(String[] args) {
System.out.println("Hello, JavaPoet!");
}
JavaPoet

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

52. TypeSpec helloWorld = TypeSpec.classBuilder("HellowWorld")
.addMethod(MethodSpec.{…})
.addModifiers(Modifier.PUBLIC, Modifier.FINAL)
.build();
public final class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, JavaPoet!");
}
}
JavaPoet

53. Tips
Find the boilerplate of daily work, eg: findViewById,
dependency graph, deep link, etc.
Find the pattern and define each component.
Label each component with annotation.
Create processor to generate code and link each
component.

54. Example

55. Factory
public interface Animal {}
public class Cat implements Animal {}
public class Dog implements Animal {}
public final class AnimalFactory {
public static Animal createAnimal(String type) {
switch(type) {
case "cat": return new Cat();
case "dog": return new Dog();
}
throw new RuntimeException("not support type");
}
}

56. Factory
public interface Animal {}
public class Cat implements Animal {}
public class Dog implements Animal {}
public final class AnimalFactory {
public static Animal createAnimal(String type) {
switch(type) {
case "cat": return new Cat();
case "dog": return new Dog();
}
throw new RuntimeException("not support type");
}
}

57. Auto Generate?
@AutoFactory
public interface Animal {}
@AutoElement(AnimalTags.CAT)
public class Cat implements Animal {}
@AutoElement(AnimalTags.DOG)
public class Dog implements Animal {}
// https://github.com/Jintin/AutoFactory

58. Example 2

59. 1 ViewHolder
public class MyAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
protected static final int TYPE_HOLDER1 = 1;
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
switch (viewType) {
case TYPE_HOLDER1: {
return new Holder1(LayoutInflater.from(context).inflate(R.layout.view1, parent, false));
}
default: throw new RuntimeException("Not support type" + viewType);
}
}
}

60. Add ViewHolder
public class MyAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
protected static final int TYPE_HOLDER1 = 1;
protected static final int TYPE_HOLDER2 = 2;
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
switch (viewType) {
case TYPE_HOLDER1: {
return new Holder1(LayoutInflater.from(context).inflate(R.layout.view1, parent, false));
}
case TYPE_HOLDER2: {
return new Holder2(LayoutInflater.from(context).inflate(R.layout.view2, parent, false));
}
default: throw new RuntimeException("Not support type" + viewType);
}
}
}

61. Add more ViewHolder
public class MyAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
protected static final int TYPE_HOLDER1 = 1;
protected static final int TYPE_HOLDER2 = 2;
protected static final int TYPE_HOLDER3 = 3;
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
switch (viewType) {
case TYPE_HOLDER1: {
return new Holder1(LayoutInflater.from(context).inflate(R.layout.view1, parent, false));
}
case TYPE_HOLDER2: {
return new Holder2(LayoutInflater.from(context).inflate(R.layout.view2, parent, false));
}
case TYPE_HOLDER3: {
return new Holder3(LayoutInflater.from(context).inflate(R.layout.view3, parent, false));
}
default: throw new RuntimeException("Not support type" + viewType);
}
}
}

62. Even more ViewHolders
public class MyAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
protected static final int TYPE_HOLDER1 = 1;
protected static final int TYPE_HOLDER2 = 2;
protected static final int TYPE_HOLDER3 = 3;
protected static final int TYPE_HOLDER4 = 4;
protected static final int TYPE_HOLDER5 = 5;
protected static final int TYPE_HOLDER6 = 6;
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
switch (viewType) {
case TYPE_HOLDER1: {
return new Holder1(LayoutInflater.from(context).inflate(R.layout.view1, parent, false));
}
case TYPE_HOLDER2: {
return new Holder2(LayoutInflater.from(context).inflate(R.layout.view2, parent, false));
}
case TYPE_HOLDER3: {
return new Holder3(LayoutInflater.from(context).inflate(R.layout.view3, parent, false));
}
case TYPE_HOLDER4: {
return new Holder4(LayoutInflater.from(context).inflate(R.layout.view4, parent, false));
}
case TYPE_HOLDER5: {
return new Holder5(LayoutInflater.from(context).inflate(R.layout.view5, parent, false));
}
case TYPE_HOLDER6: {
return new Holder6(LayoutInflater.from(context).inflate(R.layout.view6, parent, false));
}
default: throw new RuntimeException("Not support type" + viewType);
}
}
}

63. Even more Adapters
public class MyAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
protected static final int TYPE_HOLDER1 = 1;
protected static final int TYPE_HOLDER2 = 2;
protected static final int TYPE_HOLDER3 = 3;
protected static final int TYPE_HOLDER4 = 4;
protected static final int TYPE_HOLDER5 = 5;
protected static final int TYPE_HOLDER6 = 6;
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
switch (viewType) {
case TYPE_HOLDER1: {
return new Holder1(LayoutInflater.from(context).inflate(R.layout.view1, parent, false));
}
case TYPE_HOLDER2: {
return new Holder2(LayoutInflater.from(context).inflate(R.layout.view2, parent, false));
}
case TYPE_HOLDER3: {
return new Holder3(LayoutInflater.from(context).inflate(R.layout.view3, parent, false));
}
case TYPE_HOLDER4: {
return new Holder4(LayoutInflater.from(context).inflate(R.layout.view4, parent, false));
}
case TYPE_HOLDER5: {
return new Holder5(LayoutInflater.from(context).inflate(R.layout.view5, parent, false));
}
case TYPE_HOLDER6: {
return new Holder6(LayoutInflater.from(context).inflate(R.layout.view6, parent, false));
}
default: throw new RuntimeException("Not support type" + viewType);
}
}
}
public class MyAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
protected static final int TYPE_HOLDER1 = 1;
protected static final int TYPE_HOLDER2 = 2;
protected static final int TYPE_HOLDER3 = 3;
protected static final int TYPE_HOLDER4 = 4;
protected static final int TYPE_HOLDER5 = 5;
protected static final int TYPE_HOLDER6 = 6;
@Override
public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
switch (viewType) {
case TYPE_HOLDER1: {
return new Holder1(LayoutInflater.from(context).inflate(R.layout.view1, parent, false));
}
case TYPE_HOLDER2: {
return new Holder2(LayoutInflater.from(context).inflate(R.layout.view2, parent, false));
}
case TYPE_HOLDER3: {
return new Holder3(LayoutInflater.from(context).inflate(R.layout.view3, parent, false));
}
case TYPE_HOLDER4: {
return new Holder4(LayoutInflater.from(context).inflate(R.layout.view4, parent, false));
}
case TYPE_HOLDER5: {
return new Holder5(LayoutInflater.from(context).inflate(R.layout.view5, parent, false));
}
case TYPE_HOLDER6: {
return new Holder6(LayoutInflater.from(context).inflate(R.layout.view6, parent, false));
}
default: throw new RuntimeException("Not support type" + viewType);
}
}
}

64. Annotation Processing
@BindHolder(Holder1.class)
@BindHolder(Holder2.class)
@BindHolder(Holder3.class, R.layout.view3)
@BindHolder(Holder4.class, R.layout.view4)
public class MyAdapter extends MyAdapterHelper {}
@BindLayout(R.layout.item_holder1)
class ViewHolder1 extends RecyclerView.ViewHolder {}
@BindLayout(R.layout.item_holder2)
class ViewHolder2 extends RecyclerView.ViewHolder {}
// https://github.com/Jintin/ComposeAdapter

65. Reference
https://kotlinlang.org/docs/reference/annotations.html
https://docs.oracle.com/javase/8/docs/api/javax/annotation/processing/
Processor.html
https://docs.oracle.com/javase/8/docs/api/javax/lang/model/element/
Element.html
https://kotlinlang.org/docs/reference/kapt.html
https://github.com/gradle/gradle/blob/master/subprojects/docs/src/docs/
userguide/java_plugin.adoc#state-of-support-in-popular-annotation-
processors
https://medium.com/@jintin/annotation-processing-in-java-3621cb05343a

66. Reference
https://github.com/google/auto/tree/master/service
https://github.com/square/javapoet
https://github.com/square/kotlinpoet
https://github.com/Jintin/ComposeAdapter
https://github.com/Jintin/AutoFactory

67. Q&A