Lombok经常用，但是你知道它的原理是什么吗？

点击上方☝SpringForAll社区 轻松关注！

及时获取有趣有料的技术文章

本文来源：https://my.oschina.net/u/4030990/blog/3173951

相信大家在项目中都使用过Lombok，因为能够简化我们许多的代码，但是该有的功能一点也不少。那么lombok到底是个什么呢，lombok是一个可以通过简单的注解的形式来帮助我们简化消除一些必须有但显得很臃肿的 Java 代码的工具，简单来说，比如我们新建了一个类，然后在其中写了几个字段，然后通常情况下我们需要手动去建立getter和setter方法啊，构造函数啊之类的，lombok的作用就是为了省去我们手动创建这些代码的麻烦，它能够在我们编译源码的时候自动帮我们生成这些方法。

那么Lombok到底是如何做到这些的呢？其实底层就是用到了编译时注解的功能。

Lombok如何使用

Lombok是一个开源项目，代码是在lombok中，如果是gradle项目的话直接在项目中引用如下即可。

1. compile ("org.projectlombok:lombok:1.16.6")

功能

那么Lombok是做什么呢？其实很简单，一个最简单的例子就是能够通过添加注解自动生成一些方法，使我们代码更加简洁易懂。例如下面一个类。

1. @Data

2. public class TestLombok {

3. private String name;

4. private Integer age;

5. public static void main(String[] args) {

6. TestLombok testLombok = new TestLombok();

7. testLombok.setAge(12);

8. testLombok.setName("zs");

9. }

10. }

我们使用Lombok提供的 Data注解，在没有写 get、set方法的时候也能够使用其 get、set方法。我们看它编译过后的 class文件，可以看到它给我们自动生成了 get、set方法。

1. public class TestLombok {

2. private String name;

3. private Integer age;

4. public static void main(String[] args) {

5. TestLombok testLombok = new TestLombok();

6. testLombok.setAge(12);

7. testLombok.setName("zs");

8. }

9. public TestLombok() {

10. }

11. public String getName() {

12. return this.name;

13. }

14. public Integer getAge() {

15. return this.age;

16. }

17. public void setName(String name) {

18. this.name = name;

19. }

20. public void setAge(Integer age) {

21. this.age = age;

22. }

23. }

当然Lombok的功能不止如此，还有很多其他的注解帮助我们简便开发，网上有许多的关于Lombok的使用方法，这里就不再啰嗦了。正常情况下我们在项目中自定义注解，或者使用 Spring框架中 @Controller、@Service等等这类注解都是 运行时注解，运行时注解大部分都是通过反射来实现的。而 Lombok是使用编译时注解实现的。那么编译时注解是什么呢？

编译时注解

注解（也被成为元数据）为我们在代码中添加信息提供了一种形式化的方法，使我们可以在稍后某个时刻非常方便地使用这些数据。 ——————摘自《Thinking in Java》

Java中的注解分为运行时注解和编译时注解，运行时注解就是我们经常使用的在程序运行时通过反射得到我们注解的信息，然后再做一些操作。而编译时注解是什么呢？就是在程序在编译期间通过注解处理器进行处理。

• 编译期：Java语言的编译期是一段不确定的操作过程，因为它可能是将 *.java文件转化成 *.class文件的过程；也可能是指将字节码转变成机器码的过程；还可能是直接将 *.java编译成本地机器代码的过程

• 运行期：从JVM加载字节码文件到内存中，到最后使用完毕以后卸载的过程都属于运行期的范畴。

注解处理工具apt

注解处理工具apt(Annotation Processing Tool)，这是Sun为了帮助注解的处理过程而提供的工具，apt被设计为操作Java源文件，而不是编译后的类。

它是javac的一个工具，中文意思为编译时注解处理器。APT可以用来在编译时扫描和处理注解。通过APT可以获取到注解和被注解对象的相关信息，在拿到这些信息后我们可以根据需求来自动的生成一些代码，省去了手动编写。注意，获取注解及生成代码都是在代码编译时候完成的，相比反射在运行时处理注解大大提高了程序性能。APT的核心是AbstractProcessor类。

正常情况下使用APT工具只是能够生成一些文件(不仅仅是我们想象的class文件，还包括xml文件等等之类的)，并不能修改原有的文件信息。

但是此时估计会有疑问，那么 Lombok不就是在我们原有的文件中新增了一些信息吗？我在后面会有详细的解释，这里简单介绍一下，其实 Lombok是修改了Java中的抽象语法树 AST才做到了修改其原有类的信息。

接下来我们演示一下如何用 APT工具生成一个class文件，然后我们再说 Lombok是如何修改已存在的类中的属性的。

定义注解

首先当然我们需要定义自己的注解了

1. @Retention(RetentionPolicy.SOURCE) // 注解只在源码中保留

2. @Target(ElementType.TYPE) // 用于修饰类

3. public @interface GeneratePrint {

4. String value();

5. }

Retention注解上面有一个属性value，它是 RetentionPolicy类型的枚举类， RetentionPolicy枚举类中有三个值。

1. public enum RetentionPolicy {

2. SOURCE,

3. CLASS,

4. RUNTIME

5. }

• SOURCE修饰的注解：修饰的注解,表示注解的信息会被编译器抛弃，不会留在class文件中，注解的信息只会留在源文件中

• CLASS修饰的注解：表示注解的信息被保留在class文件(字节码文件)中当程序编译时，但不会被虚拟机读取在运行的时候

• RUNTIME修饰的注解：表示注解的信息被保留在class文件(字节码文件)中当程序编译时，会被虚拟机保留在运行时。所以它能够通过反射调用，所以正常运行时注解都是使用的这个参数

Target注解上面也有个属性value，它是 ElementType类型的枚举。是用来修饰此注解作用在哪的。

1. public enum ElementType {

2. TYPE,

3. FIELD,

4. METHOD,

5. PARAMETER,

6. CONSTRUCTOR,

7. LOCAL_VARIABLE,

8. ANNOTATION_TYPE,

9. PACKAGE,

10. TYPE_PARAMETER,

11. TYPE_USE

12. }

定义注解处理器

我们要定义注解处理器的话，那么就需要继承 AbstractProcessor类。继承完以后基本的框架类型如下

1. @SupportedSourceVersion(SourceVersion.RELEASE_8)

2. @SupportedAnnotationTypes("aboutjava.annotion.MyGetter")

3. public class MyGetterProcessor extends AbstractProcessor {

4. @Override

5. public synchronized void init(ProcessingEnvironment processingEnv) {

6. super.init(processingEnv);

7. }

8. @Override

9. public boolean process(Set<!--? extends TypeElement--> annotations, RoundEnvironment roundEnv) {

10. return true;

11. }

12. }

我们可以看到在子类中上面有两个注解，注解描述如下

• @SupportedSourceVersion：表示所支持的Java版本

• @SupportedAnnotationTypes：表示该处理器要处理的注解

继承了父类的两个方法，方法描述如下

• init方法：主要是获得编译时期的一些环境信息

• process方法：在编译时，编译器执行的方法。也就是我们写具体逻辑的地方

我们是演示一下如何通过继承 AbstractProcessor类来实现在编译时生成类，所以我们在 process方法中书写我们生成类的代码。如下所示。

1. @Override

2. public boolean process(Set<!--? extends TypeElement--> annotations, RoundEnvironment roundEnv) {

3. StringBuilder builder = new StringBuilder()

4. .append("package aboutjava.annotion;\n\n")

5. .append("public class GeneratedClass {\n\n") // open class

6. .append("\tpublic String getMessage() {\n") // open method

7. .append("\t\treturn \"");

8. // for each javax.lang.model.element.Element annotated with the CustomAnnotation

9. for (Element element : roundEnv.getElementsAnnotatedWith(MyGetter.class)) {

10. String objectType = element.getSimpleName().toString();

11. // this is appending to the return statement

12. builder.append(objectType).append(" says hello!\\n");

13. }

14. builder.append("\";\n") // end return

15. .append("\t}\n") // close method

16. .append("}\n"); // close class

17. try { // write the file

18. JavaFileObject source = processingEnv.getFiler().createSourceFile("aboutjava.annotion.GeneratedClass");

19. Writer writer = source.openWriter();

20. writer.write(builder.toString());

21. writer.flush();

22. writer.close();

23. } catch (IOException e) {

24. // Note: calling e.printStackTrace() will print IO errors

25. // that occur from the file already existing after its first run, this is normal

26. }

27. return true;

28. }

定义使用注解的类(测试类)

上面的两个类就是基本的工具类了，一个是定义了注解，一个是定义了注解处理器，接下来我们来定义一个测试类(TestAno.java)。我们在类上面加上我们自定的注解类。

1. @MyGetter

2. public class TestAno {

3. public static void main(String[] args) {

4. System.out.printf("1");

5. }

6. }

这样我们在编译期就能生成文件了，接下来演示一下在编译时生成文件，此时不要着急直接进行javac编译， MyGetter类是注解类没错，而 MyGetterProcessor是注解类的处理器，那么我们在编译 TestAnoJava文件的时候就会触发处理器。因此这两个类是无法一起编译的。

先给大家看一下我的目录结构

1. aboutjava

2. -- annotion

3. -- MyGetter.java

4. -- MyGetterProcessor.java

5. -- TestAno.java

所以我们先将注解类和注解处理器类进行编译

1. javac aboutjava/annotion/MyGett*

接下来进行编译我们的测试类，此时在编译时需要加上 processor参数，用来指定相关的注解处理类。

1. javac -processor aboutjava.annotion.MyGetterProcessor aboutjava/annotion/TestAno.java

大家可以看到动态图中，自动生成了Java文件。

代码地址

https://github.com/modouxiansheng/Doraemon

总结

本篇文章还会有第二篇进行讲解Lombok的原理，如何修改原有类的内容。本篇作为前置知识，简单的介绍了注解处理器是什么，如何利用注解处理器做一些我们在编译期才能够做的事情。希望大家能够自己在本机上试验一下，如果本篇有任何问题欢迎指出。

参考

• 万能的APT！编译时注解的妙用

http://zjutkz.net/2016/04/07/万能的APT！编译时注解的妙用/

• Compile time processing using annotation processor

https://riptutorial.com/java/example/19926/compile-time-processing-using-annotation-processor

• Java Annotation Processing and Creating a Builder

https://www.baeldung.com/java-annotation-processing-builder

• Lombok原理分析与功能实现

https://blog.mythsman.com/post/5d2c11c767f841464434a3bf/

• java注解处理器——在编译期修改语法树

https://blog.csdn.net/a_zhenzhen/article/details/86065063

• AOP 最后一块拼图 | AST 抽象语法树 —— 最轻量级的AOP方法

https://juejin.im/post/5c45bce5f265da612c5e2d3f

• Java Annotation Processing and Creating a Builder

https://www.baeldung.com/java-annotation-processing-builder

• Java抽象语法树AST浅析与使用

https://blog.csdn.net/peng425/article/details/102814754