济宁网上做科目一的网站/怎么开网店新手入门

---

简介

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

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

Lombok 是一个非常热门的开源项目，使用它可以有效的解决 Java 工程中那些繁琐又重复代码，例如 Setter、Getter、toString、equals、hashCode 以及非空判断等，都可以使用 Lombok 有效的解决。

1.常用注解

• @Data：注解在类上；提供类所有属性的 getting 和 setting 方法，此外还提供了equals、canEqual、hashCode、toString 方法
• @Builder：注解在类上，提供对象的构建能能力
• @Setter：注解在属性上；为属性提供 setting 方法
• @Getter：注解在属性上；为属性提供 getting 方法
• @SneakyThrows：无需在签名处显式抛出异常
• @Log4j：注解在类上；为类提供一个 属性名为log 的 log4j 日志对像
• @Slf4j: 同上
• @NoArgsConstructor：注解在类上；为类提供一个无参的构造方法
• @AllArgsConstructor：注解在类上；为类提供一个全参的构造方法

2.简单分析

Lombok不是通过字节码改写来实现的。它主要是用编译器内支持的annotation processing，直接操纵抽象语法树（AST），根据需要添加新节点。

Slf4j代码示例-编译前：

@Slf4j
public class LogExample {
}

Slf4j代码示例-编译后：

public class LogExample {private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LogExample.class);
}

Getter代码示例-编译前：

private @Getter int foo;

Getter代码示例-编译后：

 public int getFoo() {return this.foo;}

一、原理分析

我们知道 Java 的编译过程大致可以分为三个阶段：解析与填充符号表，注解处理，分析与字节码生成。
编译过程如下图所示：

而 Lombok 正是利用「注解处理」这一步进行实现的，Lombok 使用的是 JDK 6 实现的 JSR 269: Pluggable Annotation Processing API (编译期的注解处理器) ，它是在编译期时把 Lombok 的注解代码，转换为常规的 Java 方法而实现优雅地编程的。

这一点可以在程序中得到验证，比如本文刚开始用 @Data 实现的代码：

在我们编译之后，查看 Person 类的编译源码发现，代码竟然是这样的：

Lombok 的执行流程如下：

可以看出，在编译期阶段，当 Java 源码被抽象成语法树 (AST) 之后，Lombok 会根据自己的注解处理器动态的修改 AST，增加新的代码 (节点)，在这一切执行之后，再通过分析生成了最终的字节码 (.class) 文件，这就是 Lombok 的执行原理。

二、手动实现Lombok

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

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

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

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

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

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

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

import com.sun.source.tree.Tree;
import com.sun.tools.javac.api.JavacTrees;
import com.sun.tools.javac.code.Flags;
import com.sun.tools.javac.code.Type;
import com.sun.tools.javac.processing.JavacProcessingEnvironment;
import com.sun.tools.javac.tree.JCTree;
import com.sun.tools.javac.tree.TreeMaker;
import com.sun.tools.javac.tree.TreeTranslator;
import com.sun.tools.javac.util.*;import javax.annotation.processing.*;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.tools.Diagnostic;
import java.util.Set;@SupportedSourceVersion(SourceVersion.RELEASE_8)
@SupportedAnnotationTypes("com.example.lombok.MyGetter")
public class MyGetterProcessor extends AbstractProcessor {private Messager messager; // 编译时期输入日志的private JavacTrees javacTrees; // 提供了待处理的抽象语法树private TreeMaker treeMaker; // 封装了创建AST节点的一些方法private Names names; // 提供了创建标识符的方法@Overridepublic synchronized void init(ProcessingEnvironment processingEnv) {super.init(processingEnv);this.messager = processingEnv.getMessager();this.javacTrees = JavacTrees.instance(processingEnv);Context context = ((JavacProcessingEnvironment) processingEnv).getContext();this.treeMaker = TreeMaker.instance(context);this.names = Names.instance(context);}@Overridepublic boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {Set<? extends Element> elementsAnnotatedWith = roundEnv.getElementsAnnotatedWith(MyGetter.class);elementsAnnotatedWith.forEach(e -> {JCTree tree = javacTrees.getTree(e);tree.accept(new TreeTranslator() {@Overridepublic void visitClassDef(JCTree.JCClassDecl jcClassDecl) {List<JCTree.JCVariableDecl> jcVariableDeclList = List.nil();// 在抽象树中找出所有的变量for (JCTree jcTree : jcClassDecl.defs) {if (jcTree.getKind().equals(Tree.Kind.VARIABLE)) {JCTree.JCVariableDecl jcVariableDecl = (JCTree.JCVariableDecl) jcTree;jcVariableDeclList = jcVariableDeclList.append(jcVariableDecl);}}// 对于变量进行生成方法的操作jcVariableDeclList.forEach(jcVariableDecl -> {messager.printMessage(Diagnostic.Kind.NOTE, jcVariableDecl.getName() + " has been processed");jcClassDecl.defs = jcClassDecl.defs.prepend(makeGetterMethodDecl(jcVariableDecl));});super.visitClassDef(jcClassDecl);}});});return true;}private JCTree.JCMethodDecl makeGetterMethodDecl(JCTree.JCVariableDecl jcVariableDecl) {ListBuffer<JCTree.JCStatement> statements = new ListBuffer<>();// 生成表达式 例如 this.a = a;JCTree.JCExpressionStatement aThis = makeAssignment(treeMaker.Select(treeMaker.Ident(names.fromString("this")), jcVariableDecl.getName()), treeMaker.Ident(jcVariableDecl.getName()));statements.append(aThis);JCTree.JCBlock block = treeMaker.Block(0, statements.toList());// 生成入参JCTree.JCVariableDecl param = treeMaker.VarDef(treeMaker.Modifiers(Flags.PARAMETER),jcVariableDecl.getName(), jcVariableDecl.vartype, null);List<JCTree.JCVariableDecl> parameters = List.of(param);// 生成返回对象JCTree.JCExpression methodType = treeMaker.Type(new Type.JCVoidType());return treeMaker.MethodDef(treeMaker.Modifiers(Flags.PUBLIC),getNewMethodName(jcVariableDecl.getName()), methodType, List.nil(),parameters, List.nil(), block, null);}private Name getNewMethodName(Name name) {String s = name.toString();return names.fromString("get" + s.substring(0, 1).toUpperCase() + s.substring(1, name.length()));}private JCTree.JCExpressionStatement makeAssignment(JCTree.JCExpression lhs, JCTree.JCExpression rhs) {return treeMaker.Exec(treeMaker.Assign(lhs,rhs));}
}

自定义的注解处理器是我们实现简易版的 Lombok 的重中之重，我们需要继承 AbstractProcessor 类，重写它的 init() 和 process() 方法，在 process() 方法中我们先查询所有的变量，在给变量添加对应的方法。我们使用 TreeMaker 对象和 Names 来处理 AST，如上代码所示。

当这些代码写好之后，我们就可以新增一个 Person 类来试一下我们自定义的 @MyGetter 功能了，代码如下：

@MyGetter
public class Person {private String name;
}

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

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

进入的根目录如下：

使用 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

源码文件如下：

可以看到我们自定义的 getName() 方法已经成功生成了，到这里简易版的 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。

最后提醒一句，再好的技术也不是万金油，就好像再好的鞋子也得适合自己的脚才行！