This document discusses using annotation processors and compiler plugins to generate code. It provides examples of generating code to avoid boilerplate and duplication using annotation processors. It then outlines the basic steps to implement an annotation processor which includes implementing an interface, creating a provider configuration file, and compiling with the annotation processor on the classpath. Similarly, the basic steps for a compiler plugin are discussed, which involves implementing a plugin interface, creating a provider configuration file, and compiling with the plugin specified.

1. Annotation processor
and compiler plugin
as code generators.

2. Hello!
I am Oleksandr Radchykov
committed.chinchilla@gmail.com
belict

3. Agenda
1.Motivation
2.How to generate code?
3.How to annotation processor
4.How to create plugin
5.Demo

4. Motivation for
code generation

5. Getting rid of boilerplate
class MyService {
private final String name;
private final Integer version;
public MyService(String name, Integer version) {
this.name = name;
This.version = version;
}
public String getName() { return name; }
public Integer getVersion() { return version; }
}

6. @Getter
@RequiredArgsConstructor
class MyService {
private final String name;
private final Integer version;
}
6

7. Getting rid from annoying
code duplication
public String validate(Object input) {
if (income instanceof String
&& !((String) income).isEmpty()) {
return (String) income;
}
…
}

8. public String validate(Object input) {
if (income instanceof String && !income.isEmpty()) {
return income;
}
…
}
8

9. Two ways to
generate code

10. Annotation Processing
▷Java 5+
▷Takes java code and generates source files
▷You can not manipulate an existing java code
▷Use the model of processing rounds

11. Javac Plugin
▷Since Java 8
▷Can give us access to AST trees parsed from
source code
▷Can be used to add compile-time checks
▷Can run on different phases of compilation
process

12. Annotation
processor

13. 1. Implement AbstractProcessor
interface
import javax.annotation.processing.AbstractProcessor;
class MyProcessor implements AbstractProcessor {
@Override
public boolean process(
Set<? Extends TypeElement> annotations,
RoundEnvironment roundEnv) {
/*...*/
}
}

14. 2. Create provider-configuration file
MyProcessor.jar
- com/example
- MyProcessor.class
- META-INF/services
- javax.annotation.processing.Processor
Provider-configuration file should declare all
annotation processors you want to expose.

15. 3. Compilation
$ javac –cp processor.jar
*sources*.java

16. Javac plugin

17. 1. Implement Plugin interface
import com.sun.source.util.Plugin;
class MyPlugin implements Plugin {
@Override
public String getName() { return “pluginName”; }
@Override
public void init(JavacTask javacTask,
String… strings) {
/*...*/
}
}

18. 2. Create provider-configuration file
MyPlugin.jar
- com/example
- MyPlugin.class
- META-INF/services
- com.sun.source.util.Plugin
Provider-configuration file should declare all plugins
you want to expose.

19. 3. Compilation
$ javac -Xplugin:PluginName
–cp /path/to/plugin
Source.java

20. Demo

21. Questions?

22. Thanks
committed.chinchilla@gmail.com
belict