Java annotation processor

References
https://realm.io/news/360andev-ryan-harter-eliminate-boilerplate/
https://www.youtube.com/watch?v=dOcs-NKK-RA
https://www.youtube.com/watch?v=43FFfTyDYEg
http://hannesdorfmann.com/annotation-processing/annotationprocessing101
http://blog.stablekernel.com/the-10-step-guide-to-annotation-processing-in-android-studio
http://hannesdorfmann.com/annotation-processing/annotationprocessing101
https://www.youtube.com/watch?v=dBUAqPs0TB0

Transcript

1. Java annotation processors Jaime Toca Muñoz jaime.toca.munoz@gmail.com @toca_jaime Oct 2016
2. Parcelable - Great way to serialize java objects between contexts - 10x time faster than java serializable - A lot of boilerplate code Money.class public class Money implements Parcelable { private Currency currency; private long amount; public Money(Currency currency, long amount){ this.currency = currency; this.amount = amount; }
3. Parcelable Money.class @Override public int describeContents() { return 0; } @Override public void writeToParcel(Parcel dest, int flags) { dest.writeSerializable(this.currency); dest.writeLong(this.amount); } protected Money(Parcel in) { this.currency = (Currency) in.readSerializable(); this.amount = in.readLong(); }
4. Parcelable Money.class public static final Parcelable.Creator<Money> CREATOR = new Parcelable.Creator<Money>() { @Override public Money createFromParcel(Parcel source) { return new Money(source); } @Override public Money[] newArray(int size) { return new Money[size]; } };
5. @Parceler
6. Parceler @Parcel public class Money { private Currency currency; private long amount; public Money(Currency currency, long amount){ this.currency = currency; this.amount = amount; } public Currency getCurrency() { return currency; } public long getAmount() { return amount; } } Bundle bundle = new Bundle(); bundle.putParcelable("Money", Parcels.wrap(money)); Money money = Parcels.unwrap(getIntent(). getParcelableExtra("Money"));
7. @ButterKnife
8. ButterKnife - Eliminate findViewById with @BindView - Group multiples views in a list or array - Eliminate anonymous inner-classes for listeners by annotating methods with @OnClick @BindView(R.id.pass) EditText password; @OnClick(R.id.login) void login() { //call loginpresenter } password = (EditText) findViewById(R.id.pass); textView.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { } });
9. @AutoValue
10. Value Types public final class Money { private Currency currency; private long amount; public Money(Currency currency, long amount) { this.currency = currency; this.amount = amount; } public Currency getCurrency() { return currency; } public long getAmount() { return amount; } } Money money1 = new Money(esCurrency,1123); Money money2 = new Money(esCurrency,1123); assert(money1.equals(money2)); //fails
11. AutoValue @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Money money = (Money) o; if (Double.compare(money.amount, amount) != 0) return false; return currency.equals(money.currency); } @Override public int hashCode() { int result; long temp; result = currency.hashCode(); result = 31 * result + (int) (amount ^ (amount >>> 32)); return result; } } @Override public String toString() { return "Money{" + "currency=" + currency + ", amount=" + amount + '}'; }
12. AutoValue @AutoValue public abstract class Money { public abstract Currency currency(); public abstract long amount(); public static Money create(Currency currency, long amount) { return new AutoValue_Money(currency, amount); } } - Removes boilerplate code - You can add additional code to this class if you want - Hidden benefit (no need for testing)
13. Annotation Processor
14. MyView.java @Override protected void initOneCMSText(View view) { mTvVariable2.setText(LocalizablesFacade.getString(getActivity(), OneCMSKeys.KEYVARIABLE1)); mTvVariable3.setText(LocalizablesFacade.getString(getActivity(), OneCMSKeys.KEYVARIABLE2)); mTvVariable4.setText(LocalizablesFacade.getString(getActivity(), OneCMSKeys.KEYVARIABLE3)); mTvVariable5.setText(LocalizablesFacade.getString(getActivity(), OneCMSKeys.KEYVARIABLE4)); mTvVariable6.setText(LocalizablesFacade.getString(getActivity(), OneCMSKeys.KEYVARIABLE5)); mTvVariable7.setText(LocalizablesFacade.getString(getActivity(), OneCMSKeys.KEYVARIABLE6)); ……. } Content Processor
15. Content Processor MyView.java @InjectContent(key = KEYVARIABLE1) TextView mTvVariable1 @InjectContent(key = KEYVARIABLE2) TextView mTvVariable2 @InjectContent(key = KEYVARIABLE3) TextView mTvVariable3 …. @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); InitContent.InjectMyViewContent(this); }
16. Part 1: Annotations
17. Annotations @Target(value = ElementType.FIELD) @Retention(RetentionPolicy.SOURCE) public @interface InjectContent { String key(); }
18. Part 2: The processor
19. Registering your processor - com/example/myCustomProcessor.java - META-INF/services/javax.annotation.processing.Processor - com.example.myCustomProcessor - Use service loader discovery file
20. Dependencies dependencies { compile project(':annotation) apt project(':contentProcessor) }
21. The processor public class ContentProcessor extends AbstractProcessor { ……... } public abstract class AbstractProcessor implements Processor { public Set<String> getSupportedAnnotationTypes(); public SourceVersion getSupportedSourceVersion(); public synchronized void init(ProcessingEnvironment processingEnv); public abstract boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv); }
22. The processor @Override public Set<String> getSupportedAnnotationTypes() { return Collection.singleton(InjectContent.class.getCanonicalName()); } @Override public SourceVersion getSupportedSourceVersion() { return SourceVersion.latestSupported(); }
23. The processor @Override public synchronized void init(ProcessingEnvironment processingEnv) { super.init(processingEnv); messager = processingEnv.getMessager(); filer = processingEnv.getFiler(); elementUtils = processingEnv.getElementUtils(); typeUtils = processingEnv.getTypeUtils(); }
24. The processor @Override public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) { ArrayList<AnnotatedField> annotatedFields = new ArrayList<>(); for (Element annotatedElement : roundEnv.getElementsAnnotatedWith(InjectContent.class)) { String variableName = annotatedElement.toString(); TypeElement annotatedFieldData = (TypeElement) annotatedElement.getEnclosingElement(); String oneCMSKey = annotatedElement.getAnnotation(InjectContent.class).key(); annotatedFields.add(buildAnnotatedField(variableName , annotatedFieldData, oneCMSKey)); …………. } if (!annotatedFields.isEmpty()){ generateCode(annotatedFields); } ………...
25. Part 3: Code generation
26. Java Poet: Code generation API - Developed by Square - Code generation becomes easy - Uses fluent API with builders - Based on Specs - TypeSpecs - MethodSpecs - ParameterSpec - FieldSpec
27. Java Poet: Code generation API package com.example.helloworld; public final class HelloWorld { public static void main(String[] args) { System.out.println("Hello, 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();
28. Code generation - We want to generate a class with N methods - Each method will set the oneCMS content for all the fields in that View public final class InitContent { public static void injectMainActivityContent(MainActivity mainActivity) { mainActivity.mTvHello.setText(//access localizable); mainActivity.mTvBye.setText(//access localizable); mainActivity.mTvAwesome.setText(//access localizable); mainActivity.mTvWhatever.setText(//access localizable); } public static void injectSecondActivityContent(SecondActivity secondActivity) { secondActivity.mTvHello.setText(//access localizable); secondActivity.mTvWhatever.setText(//access localizable); } …... }
29. Code generation private void generateCode(ArrayList<AnnotatedField> annotatedFields) throws NoPackageNameException, IOException { String packageName = Utils.getPackageName(elementUtils, nnotatedFields.get(0).getTypeElement()); TypeSpec generatedClass = CodeGenerator.generateClass(annotatedFields); JavaFile javaFile = builder(packageName, generatedClass).build(); javaFile.writeTo(filer); }
30. Code generation public static TypeSpec generateClass(List <AnnotatedField> annotatedFields) { TypeSpec.Builder builder = classBuilder(CLASS_NAME).addModifiers(PUBLIC, FINAL); HashMap<String, List <annotatedField>> bindingClass = bindClassesWithAnnotation(annotatedFields); …. for (ViewClass viewClass : viewClasses) { builder.addMethod(createInitContentMethod(bindingClass)) } return builder.build(); } private static MethodSpec createInitContentMethod(List <AnnotatedField> annotatedFields){ …. String methodName = PREFIX_METHOD_INIT + annotatedField.getClassName() + SUFIX_METHOD_INIT; String methodParameterName = annotatedField.getClassName().toLowerCase(); …. return methodBuilder(methodName) .addModifiers(PUBLIC, STATIC) .addParameter(get(annotatedField.getTypeElement().asType()), methodParameterName) .addStatement(methodParameterName +"." + variableName + SET_TEXT + "(\"LocalizableAccessHere\")") CONCATENATE THIS .returns(TypeName.VOID) .build(); }
31. Testing : Compile testing assertAbout(javaSource()) .that(JavaFileObjects.forResource("HelloWorld.java")) .processedWith(new MyAnnotationProcessor()) .compilesWithoutError() .and().generatesSources(JavaFileObjects.forResource("GeneratedHelloWorld.java")); https://github.com/google/compile-testing
32. https://github.com/JaimeToca/AnnotationProcessor-Example
33. References - https://realm.io/news/360andev-ryan-harter-eliminate-boilerplate/ - https://www.youtube.com/watch?v=dOcs-NKK-RA - https://www.youtube.com/watch?v=43FFfTyDYEg - http://hannesdorfmann.com/annotation-processing/annotationprocessing101 - http://blog.stablekernel.com/the-10-step-guide-to-annotation-processing-in-an droid-studio - http://hannesdorfmann.com/annotation-processing/annotationprocessing101 - https://www.youtube.com/watch?v=dBUAqPs0TB0