世界上只有一种英雄主义，就是看清生活的真相之后依然热爱生活。

对于 Lombok 我相信大部分人都不陌生，但对于它的实现原理以及缺点却鲜为人知，而本文将会从 Lombok 的原理出发，手撸一个简易版的 Lombok，让你理解这个热门技术背后的执行原理，以及它的优缺点。

简介

在讲原理之前，我们先来复习一下 Lombok (老司机可直接跳过本段)。
Lombok 是一个非常热门的开源项目 (https://github.com/rzwitserloot/lombok)，使用它可以有效的解决 Java 工程中那些繁琐又重复代码，例如 Setter、Getter、toString、equals、hashCode 以及非空判断等，都可以使用 Lombok 有效的解决。

使用

1.添加 Lombok 插件

在 IDE 中必须安装 Lombok 插件，才能正常调用被 Lombok 修饰的代码，以 Idea 为例，添加的步骤如下：

  • 点击 File > Settings > Plugins 进入插件管理页面
  • 点击 Browse repositories…
  • 搜索 Lombok Plugin
  • 点击 Install plugin 安装插件
  • 重启 IntelliJ IDEA

安装完成，如下图所示：手撸一个Lombok(原理) - 图1

2.添加 Lombok 库

接下来我们需要在项目中添加最新的 Lombok 库，如果是 Maven 项目，直接在 pom.xml 中添加如下配置：

  1. <dependencies>
  2.   <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
  3.     <dependency>
  4.         <groupId>org.projectlombok</groupId>
  5.         <artifactId>lombok</artifactId>
  6.         <version>1.18.12</version>
  7.         <scope>provided</scope>
  8.     </dependency>
  9. </dependencies>

如果是 JDK 9+ 可使用模块的方式添加，配置如下：

  1. <annotationProcessorPaths>
  2.     <path>
  3.         <groupId>org.projectlombok</groupId>
  4.         <artifactId>lombok</artifactId>
  5.         <version>1.18.12</version>
  6.     </path>
  7. </annotationProcessorPaths>

3.使用 Lombok

接下来到了前半部分中最重要的 Lombok 使用环节了，我们先来看在没有使用 Lombok 之前的代码：

  1. publicclass Person {
  2.     private Integer id;
  3.     private String name;
  4.     public Integer getId() {
  5.         return id;
  6.     }
  7.     public void setId(Integer id) {
  8.         this.id = id;
  9.     }
  10.     public String getName() {
  11.         return name;
  12.     }
  13.     public void setName(String name) {
  14.         this.name = name;
  15.     }
  16. }

这是使用 Lombok 之后的代码：

  1. @Getter
  2. @Setter
  3. publicclass Person {
  4.     private Integer id;
  5.     private String name;
  6. }

可以看出在 Lombok 之后，用一个注解就搞定了之前所有 Getter/Setter 的代码，让代码瞬间优雅了很多。
Lombok 所有注解如下：

  • val：用在局部变量前面，相当于将变量声明为 final；
  • @NonNull：给方法参数增加这个注解会自动在方法内对该参数进行是否为空的校验，如果为空，则抛出 NPE（NullPointerException）；
  • @Cleanup：自动管理资源，用在局部变量之前，在当前变量范围内即将执行完毕退出之前会自动清理资源，自动生成 try-finally 这样的代码来关闭流；
  • @Getter/@Setter：用在属性上，再也不用自己手写 setter 和 getter 方法了，还可以指定访问范围；
  • @ToString：用在类上可以自动覆写 toString 方法，当然还可以加其他参数，例如 @ToString(exclude=”id”) 排除 id 属性，或者 @ToString(callSuper=true, includeFieldNames=true) 调用父类的 toString 方法，包含所有属性；
  • @EqualsAndHashCode：用在类上自动生成 equals 方法和 hashCode 方法；
  • @NoArgsConstructor, @RequiredArgsConstructor and @AllArgsConstructor：用在类上，自动生成无参构造和使用所有参数的构造函数以及把所有 @NonNull 属性作为参数的构造函数，如果指定 staticName=”of” 参数，同时还会生成一个返回类对象的静态工厂方法，比使用构造函数方便很多；
  • @Data：注解在类上，相当于同时使用了 @ToString、@EqualsAndHashCode、@Getter、@Setter 和 @RequiredArgsConstrutor 这些注解，对于 POJO 类十分有用；
  • @Value：用在类上，是 @Data 的不可变形式，相当于为属性添加 final 声明，只提供 getter 方法，而不提供 setter 方法；
  • @Builder：用在类、构造器、方法上，为你提供复杂的 builder APIs，让你可以像如下方式一样调用Person.builder().name(“xxx”).city(“xxx”).build()；
  • @SneakyThrows：自动抛受检异常，而无需显式在方法上使用 throws 语句；
  • @Synchronized：用在方法上，将方法声明为同步的，并自动加锁，而锁对象是一个私有的属性 或LOCK，而 Java 中的 synchronized 关键字锁对象是 this，锁在 this 或者自己的类对象上存在副作用，就是你不能阻止非受控代码去锁 this 或者类对象，这可能会导致竞争条件或者其它线程错误；
  • @Getter(lazy=true)：可以替代经典的 Double Check Lock 样板代码；
  • @Log：根据不同的注解生成不同类型的 log 对象，但是实例名称都是 log，有六种可选实现类
    • @CommonsLog Creates log = org.apache.commons.logging.LogFactory.getLog(LogExample.class);
    • @Log Creates log = java.util.logging.Logger.getLogger(LogExample.class.getName());
    • @Log4j Creates log = org.apache.log4j.Logger.getLogger(LogExample.class);
    • @Log4j2 Creates log = org.apache.logging.log4j.LogManager.getLogger(LogExample.class);
    • @Slf4j Creates log = org.slf4j.LoggerFactory.getLogger(LogExample.class);
    • @XSlf4j Creates log = org.slf4j.ext.XLoggerFactory.getXLogger(LogExample.class);

它们的具体使用如下：

① val 使用

  1. val sets = new HashSet<String>();
  2. // 相当于
  3. final Set<String> sets = new HashSet<>();

② NonNull 使用

  1. public void notNullExample(@NonNull String string) {
  2.     string.length();
  3. }
  4. // 相当于
  5. public void notNullExample(String string) {
  6.     if (string != null) {
  7.         string.length();
  8.     } else {
  9.         throw new NullPointerException("null");
  10.     }
  11. }

③ Cleanup 使用

  1. public static void main(String[] args) {
  2.     try {
  3.         @Cleanup InputStream inputStream = new FileInputStream(args[0]);
  4.     } catch (FileNotFoundException e) {
  5.         e.printStackTrace();
  6.     }
  7.     // 相当于
  8.     InputStream inputStream = null;
  9.     try {
  10.         inputStream = new FileInputStream(args[0]);
  11.     } catch (FileNotFoundException e) {
  12.         e.printStackTrace();
  13.     } finally {
  14.         if (inputStream != null) {
  15.             try {
  16.                 inputStream.close();
  17.             } catch (IOException e) {
  18.                 e.printStackTrace();
  19.             }
  20.         }
  21.     }
  22. }

④ Getter/Setter 使用

  1. @Setter(AccessLevel.PUBLIC)
  2. @Getter(AccessLevel.PROTECTED)
  3. private int id;
  4. private String shap;

⑤ ToString 使用

  1. @ToString(exclude = "id", callSuper = true, includeFieldNames = true)
  2. publicclass LombokDemo {
  3.     privateint id;
  4.     private String name;
  5.     privateint age;
  6.     public static void main(String[] args) {
  7.         // 输出 LombokDemo(super=LombokDemo@48524010, name=null, age=0)
  8.         System.out.println(new LombokDemo());
  9.     }
  10. }

⑥ EqualsAndHashCode 使用

  1. @EqualsAndHashCode(exclude = {"id", "shape"}, callSuper = false)
  2. public class LombokDemo {
  3.     private int id;
  4.     private String shap;
  5. }

⑦ NoArgsConstructor、RequiredArgsConstructor、AllArgsConstructor 使用

  1. @NoArgsConstructor
  2. @RequiredArgsConstructor(staticName = "of")
  3. @AllArgsConstructor
  4. publicclass LombokDemo {
  5.     @NonNull
  6.     privateint id;
  7.     @NonNull
  8.     private String shap;
  9.     privateint age;
  10.     public static void main(String[] args) {
  11.         new LombokDemo(1, "Java");
  12.         // 使用静态工厂方法
  13.         LombokDemo.of(2, "Java");
  14.         // 无参构造
  15.         new LombokDemo();
  16.         // 包含所有参数
  17.         new LombokDemo(1, "Java", 2);
  18.     }
  19. }

⑧ Builder 使用

  1. @Builder
  2. public class BuilderExample {
  3.     private String name;
  4.     private int age;
  5.     @Singular
  6.     private Set<String> occupations;
  7.     public static void main(String[] args) {
  8.         BuilderExample test = BuilderExample.builder().age(11).name("Java").build();
  9.     }
  10. }

⑨ SneakyThrows 使用

  1. publicclass ThrowsTest {
  2.     @SneakyThrows()
  3.     public void read() {
  4.         InputStream inputStream = new FileInputStream("");
  5.     }
  6.     @SneakyThrows
  7.     public void write() {
  8.         thrownew UnsupportedEncodingException();
  9.     }
  10.     // 相当于
  11.     public void read() throws FileNotFoundException {
  12.         InputStream inputStream = new FileInputStream("");
  13.     }
  14.     public void write() throws UnsupportedEncodingException {
  15.         thrownew UnsupportedEncodingException();
  16.     }
  17. }

⑩ Synchronized 使用

  1. public class SynchronizedDemo {
  2.     @Synchronized
  3.     public static void hello() {
  4.         System.out.println("world");
  5.     }
  6.     // 相当于
  7.     private static final Object $LOCK = new Object[0];
  8.     public static void hello() {
  9.         synchronized ($LOCK) {
  10.             System.out.println("world");
  11.         }
  12.     }
  13. }

⑪ Getter(lazy = true) 使用

  1. public class GetterLazyExample {
  2.     @Getter(lazy = true)
  3.     private final double[] cached = expensive();
  4.     private double[] expensive() {
  5.         double[] result = new double[1000000];
  6.         for (int i = 0; i < result.length; i++) {
  7.             result[i] = Math.asin(i);
  8.         }
  9.         return result;
  10.     }
  11. }
  12. // 相当于
  13. import java.util.concurrent.atomic.AtomicReference;
  14. public class GetterLazyExample {
  15.     private final AtomicReference<java.lang.Object> cached = new AtomicReference<>();
  16.     public double[] getCached() {
  17.         java.lang.Object value = this.cached.get();
  18.         if (value == null) {
  19.             synchronized (this.cached) {
  20.                 value = this.cached.get();
  21.                 if (value == null) {
  22.                     final double[] actualValue = expensive();
  23.                     value = actualValue == null ? this.cached : actualValue;
  24.                     this.cached.set(value);
  25.                 }
  26.             }
  27.         }
  28.         return (double[]) (value == this.cached ? null : value);
  29.     }
  30.     private double[] expensive() {
  31.         double[] result = new double[1000000];
  32.         for (int i = 0; i < result.length; i++) {
  33.             result[i] = Math.asin(i);
  34.         }
  35.         return result;
  36.     }
  37. }

原理分析

我们知道 Java 的编译过程大致可以分为三个阶段：

  1. 解析与填充符号表
  2. 注解处理
  3. 分析与字节码生成

编译过程如下图所示：image.gif而 Lombok 正是利用「注解处理」这一步进行实现的，Lombok 使用的是 JDK 6 实现的 JSR 269: Pluggable Annotation Processing API (编译期的注解处理器) ，它是在编译期时把 Lombok 的注解代码，转换为常规的 Java 方法而实现优雅地编程的。
这一点可以在程序中得到验证，比如本文刚开始用 @Data 实现的代码：
手撸一个Lombok(原理) - 图3

在我们编译之后，查看 Person 类的编译源码发现，代码竟然是这样的：
手撸一个Lombok(原理) - 图4
可以看出 Person 类在编译期被注解翻译器修改成了常规的 Java 方法，添加 Getter、Setter、equals、hashCode 等方法。
Lombok 的执行流程如下：
手撸一个Lombok(原理) - 图5
可以看出，在编译期阶段，当 Java 源码被抽象成语法树 (AST) 之后，Lombok 会根据自己的注解处理器动态的修改 AST，增加新的代码 (节点)，在这一切执行之后，再通过分析生成了最终的字节码 (.class) 文件，这就是 Lombok 的执行原理。

手撸一个 Lombok

我们实现一个简易版的 Lombok 自定义一个 Getter 方法，我们的实现步骤是：

  1. 自定义一个注解标签接口，并实现一个自定义的注解处理器；
  2. 利用 tools.jar 的 javac api 处理 AST (抽象语法树)
  3. 使用自定义的注解处理器编译代码。

这样就可以实现一个简易版的 Lombok 了。

1.定义自定义注解和注解处理器

首先创建一个 MyGetter.java 自定义一个注解，代码如下：

  1. import java.lang.annotation.ElementType;
  2. import java.lang.annotation.Retention;
  3. import java.lang.annotation.RetentionPolicy;
  4. import java.lang.annotation.Target;
  5. @Retention(RetentionPolicy.SOURCE) // 注解只在源码中保留
  6. @Target(ElementType.TYPE) // 用于修饰类
  7. public@interface MyGetter { // 定义 Getter
  8. }

再实现一个自定义的注解处理器，代码如下：

  1. import com.sun.source.tree.Tree;
  2. import com.sun.tools.javac.api.JavacTrees;
  3. import com.sun.tools.javac.code.Flags;
  4. import com.sun.tools.javac.code.Type;
  5. import com.sun.tools.javac.processing.JavacProcessingEnvironment;
  6. import com.sun.tools.javac.tree.JCTree;
  7. import com.sun.tools.javac.tree.TreeMaker;
  8. import com.sun.tools.javac.tree.TreeTranslator;
  9. import com.sun.tools.javac.util.*;
  10. import javax.annotation.processing.*;
  11. import javax.lang.model.SourceVersion;
  12. import javax.lang.model.element.Element;
  13. import javax.lang.model.element.TypeElement;
  14. import javax.tools.Diagnostic;
  15. import java.util.Set;
  16. @SupportedSourceVersion(SourceVersion.RELEASE_8)
  17. @SupportedAnnotationTypes("com.example.lombok.MyGetter")
  18. publicclass MyGetterProcessor extends AbstractProcessor {
  19.     private Messager messager; // 编译时期输入日志的
  20.     private JavacTrees javacTrees; // 提供了待处理的抽象语法树
  21.     private TreeMaker treeMaker; // 封装了创建AST节点的一些方法
  22.     private Names names; // 提供了创建标识符的方法
  23.     @Override
  24.     public synchronized void init(ProcessingEnvironment processingEnv) {
  25.         super.init(processingEnv);
  26.         this.messager = processingEnv.getMessager();
  27.         this.javacTrees = JavacTrees.instance(processingEnv);
  28.         Context context = ((JavacProcessingEnvironment) processingEnv).getContext();
  29.         this.treeMaker = TreeMaker.instance(context);
  30.         this.names = Names.instance(context);
  31.     }
  32.     @Override
  33.     public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
  34.         Set<? extends Element> elementsAnnotatedWith = roundEnv.getElementsAnnotatedWith(MyGetter.class);
  35.         elementsAnnotatedWith.forEach(e -> {
  36.             JCTree tree = javacTrees.getTree(e);
  37.             tree.accept(new TreeTranslator() {
  38.                 @Override
  39.                 public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
  40.                     List<JCTree.JCVariableDecl> jcVariableDeclList = List.nil();
  41.                     // 在抽象树中找出所有的变量
  42.                     for (JCTree jcTree : jcClassDecl.defs) {
  43.                         if (jcTree.getKind().equals(Tree.Kind.VARIABLE)) {
  44.                             JCTree.JCVariableDecl jcVariableDecl = (JCTree.JCVariableDecl) jcTree;
  45.                             jcVariableDeclList = jcVariableDeclList.append(jcVariableDecl);
  46.                         }
  47.                     }
  48.                     // 对于变量进行生成方法的操作
  49.                     jcVariableDeclList.forEach(jcVariableDecl -> {
  50.                         messager.printMessage(Diagnostic.Kind.NOTE, jcVariableDecl.getName() + " has been processed");
  51.                         jcClassDecl.defs = jcClassDecl.defs.prepend(makeGetterMethodDecl(jcVariableDecl));
  52.                     });
  53.                     super.visitClassDef(jcClassDecl);
  54.                 }
  55.             });
  56.         });
  57.         returntrue;
  58.     }
  59.     private JCTree.JCMethodDecl makeGetterMethodDecl(JCTree.JCVariableDecl jcVariableDecl) {
  60.         ListBuffer<JCTree.JCStatement> statements = new ListBuffer<>();
  61.         // 生成表达式 例如 this.a = a;
  62.         JCTree.JCExpressionStatement aThis = makeAssignment(treeMaker.Select(treeMaker.Ident(
  63.                 names.fromString("this")), jcVariableDecl.getName()), treeMaker.Ident(jcVariableDecl.getName()));
  64.         statements.append(aThis);
  65.         JCTree.JCBlock block = treeMaker.Block(0, statements.toList());
  66.         // 生成入参
  67.         JCTree.JCVariableDecl param = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER),
  68.                 jcVariableDecl.getName(), jcVariableDecl.vartype, null);
  69.         List<JCTree.JCVariableDecl> parameters = List.of(param);
  70.         // 生成返回对象
  71.         JCTree.JCExpression methodType = treeMaker.Type(new Type.JCVoidType());
  72.         return treeMaker.MethodDef(treeMaker.Modifiers(Flags.PUBLIC),
  73.                 getNewMethodName(jcVariableDecl.getName()), methodType, List.nil(),
  74.                 parameters, List.nil(), block, null);
  75.     }
  76.     private Name getNewMethodName(Name name) {
  77.         String s = name.toString();
  78.         return names.fromString("get" + s.substring(0, 1).toUpperCase() + s.substring(1, name.length()));
  79.     }
  80.     private JCTree.JCExpressionStatement makeAssignment(JCTree.JCExpression lhs, JCTree.JCExpression rhs) {
  81.         return treeMaker.Exec(
  82.                 treeMaker.Assign(
  83.                         lhs,
  84.                         rhs
  85.                 )
  86.         );
  87.     }
  88. }

自定义的注解处理器是我们实现简易版的 Lombok 的重中之重，我们需要继承 AbstractProcessor 类，重写它的 init() 和 process() 方法，在 process() 方法中我们先查询所有的变量，在给变量添加对应的方法。我们使用 TreeMaker 对象和 Names 来处理 AST，如上代码所示。
当这些代码写好之后，我们就可以新增一个 Person 类来试一下我们自定义的 @MyGetter 功能了，代码如下：

  1. @MyGetter
  2. publicclass Person {
  3.     private String name;
  4. }

2.使用自定义的注解处理器编译代码

上面的所有流程执行完成之后，我们就可以编译代码测试效果了。首先，我们先进入代码的根目录，执行以下三条命令。
进入的根目录如下：
image.gif

① 使用 tools.jar 编译自定义的注解器

javac -cp $JAVA_HOME/lib/tools.jar MyGetter* -d .

注意：命令最后面有一个“.”表示当前文件夹。
② 使用自定义注解器，编译 Person 类

javac -processor com.example.lombok.MyGetterProcessor Person.java

③ 查看 Person 源码

javap -p Person.class

源码文件如下：
手撸一个Lombok(原理) - 图7

可以看到我们自定义的 getName() 方法已经成功生成了**，到这里简易版的 Lombok 就大功告成了。

Lombok 优缺点

Lombok 的优点很明显，它可以让我们写更少的代码，节约了开发时间，并且让代码看起来更优雅，它的缺点有以下几个。

缺点1：降低了可调试性

Lombok 会帮我们自动生成很多代码，但这些代码是在编译期生成的，因此在开发和调试阶段这些代码可能是“丢失的”，这就给调试代码带来了很大的不便。

缺点2：可能会有兼容性问题

Lombok 对于代码有很强的侵入性，加上现在 JDK 版本升级比较快，每半年发布一个版本，而 Lombok 又属于第三方项目，并且由开源团队维护，因此就没有办法保证版本的兼容性和迭代的速度，进而可能会产生版本不兼容的情况。

缺点3：可能会坑到队友

尤其对于组人来的新人可能影响更大，假如这个之前没用过 Lombok，当他把代码拉下来之后，因为没有安装 Lombok 的插件，在编译项目时，就会提示找不到方法等错误信息，导致项目编译失败，进而影响了团结成员之间的协作。

缺点4：破坏了封装性

面向对象封装的定义是：通过访问权限控制，隐藏内部数据，外部仅能通过类提供的有限的接口访问和修改内部数据。
也就是说，我们不应该无脑的使用 Lombok 对外暴露所有字段的 Getter/Setter 方法，因为有些字段在某些情况下是不允许直接修改的，比如购物车中的商品数量，它直接影响了购物详情和总价，因此在修改的时候应该提供统一的方法，进行关联修改，而不是给每个字段添加访问和修改的方法。

小结

本文我们介绍了 Lombok 的使用以及执行原理，它是通过 JDK 6 实现的 JSR 269: Pluggable Annotation Processing API (编译期的注解处理器) ，在编译期时把 Lombok 的注解转换为 Java 的常规方法的，我们可以通过继承 AbstractProcessor 类，重写它的 init() 和 process() 方法，实现一个简易版的 Lombok。但同时 Lombok 也存在这一些使用上的缺点，比如：降低了可调试性、可能会有兼容性等问题，因此我们在使用时要根据自己的业务场景和实际情况，来选择要不要使用 Lombok，以及应该如何使用 Lombok。
最后提醒一句，再好的技术也不是万金油，就好像再好的鞋子也得适合自己的脚才行！

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