Lombok

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

一、安装插件

在 IDE 中必须安装 Lombok 插件，才能正常调用被 Lombok 修饰的代码，以 Idea 为例，添加的步骤如下：
Settings 👉🏻 Plugins 👉🏻 Marketplace 👉🏻 搜索 Lombok 👉🏻 点击 Install 进行安装

二、pom依赖

<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
	<version>1.18.12</version>
	<scope>provided</scope>
</dependency>

三、基本注解

注释	作用
@Getter	自动添加 getter 方法
@Setter	自动添加 setter 方法
@ToString	自动添加 toString 方法
@EqualsAndHashCode	自动添加 equals 和 hashCode 方法
@NoArgsConstructor	自动添加无参构造方法
@AllArgsConstructor	自动添加全属性构造方法，顺序按照属性的定义顺序
@NonNull	属性不能为 null
@RequiredArgsConstructor	自动添加必须属性的构造方法，final + @NonNull 的属性为必须

四、组合注解

注解	作用
@Data	@Getter + @Setter + @ToString + @EqualsAndHashCode + @RequiredArgsConstructor + @NoArgsConstructor

五、日志注解

注解	作用
@Slf4j	添加一个名为 log 的日志，使用 slf4j

六、示例

6.1 val

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

6.2 NonNull

public void notNullExample(@NonNull String string) {
    string.length();
}
// 相当于
/**
public void notNullExample(String string) {
    if (string != null) {
        string.length();
    } else {
        throw new NullPointerException("null");
    }
}
*/

6.3 Cleanup

try {
	@Cleanup InputStream inputStream = new FileInputStream(args[0]);
} catch (FileNotFoundException e) {
    e.printStackTrace();
}
// 相当于
/**
InputStream inputStream = null;
try {
	inputStream = new FileInputStream(args[0]);
} catch (FileNotFoundException e) {
	e.printStackTrace();
} finally {
	if (inputStream != null) {
        try {
            inputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
*/

6.4 Getter/Setter

@Setter(AccessLevel.PUBLIC)
@Getter(AccessLevel.PROTECTED)
private String name;

6.5 ToString

@ToString(exclude = "id", callSuper = true, includeFieldNames = true)
public class LombokDemo {
    private Long id;
    private String name;
    private Integer age;
    public static void main(String[] args) {
        // 输出 LombokDemo(super=LombokDemo@28623019, name=null, age=null)
        System.out.println(new LombokDemo());
    }
}

6.6 EqualsAndHashCode

@EqualsAndHashCode(exclude = {"id", "name"}, callSuper = false)
public class LombokDemo {
    private Long id;
    private String name;
}

6.7 NoArgsConstructor、RequiredArgsConstructor、AllArgsConstructor

@NoArgsConstructor
@RequiredArgsConstructor(staticName = "of")
@AllArgsConstructor
public class LombokDemo {
    @NonNull
    private Long id;
    @NonNull
    private String name;
    private int age;
    
    public static void main(String[] args) {
        new LombokDemo(1L, "Java");
        // 使用静态工厂方法
        LombokDemo.of(2L, "Java");
        // 无参构造
        new LombokDemo();
        // 包含所有参数
        new LombokDemo(1L, "Java", 2);
    }
}

6.9 Builder

@Builder
public class BuilderExample {
    private String name;
    private Integer age;
    @Singular
    private Set<String> occupations;
    
    public static void main(String[] args) {
        BuilderExample test = BuilderExample.builder().age(11).name("Java").build();
    }
}

6.10 SneakyThrows

public class ThrowsTest {
    @SneakyThrows()
    public void read() {
        InputStream inputStream = new FileInputStream("");
    }
    @SneakyThrows
    public void write() {
        throw new UnsupportedEncodingException();
    }
    // 相当于
    /*public void read() throws FileNotFoundException {
        InputStream inputStream = new FileInputStream("");
    }
    public void write() throws UnsupportedEncodingException {
        throw new UnsupportedEncodingException();
    }*/
}

6.11 Synchronized

public class SynchronizedDemo {
    @Synchronized
    public static void hello() {
        System.out.println("world");
    }
    // 相当于
    /*private static final Object $LOCK = new Object[0];
    public static void hello() {
        synchronized ($LOCK) {
            System.out.println("world");
        }
    }*/
}

6.12 Getter(lazy = true)

@Getter(lazy=true)：可以替代经典的 Double Check Lock 样板代码

public class GetterLazyExample {
    @Getter(lazy = true)
    private final double[] cached = expensive();
    private double[] expensive() {
        double[] result = new double[1000000];
        for (int i = 0; i < result.length; i++) {
            result[i] = Math.asin(i);
        }
        return result;
    }
}
// 相当于
/*import java.util.concurrent.atomic.AtomicReference;
public class GetterLazyExample {
    private final AtomicReference<java.lang.Object> cached = new AtomicReference<>();
    public double[] getCached() {
        java.lang.Object value = this.cached.get();
        if (value == null) {
            synchronized (this.cached) {
                value = this.cached.get();
                if (value == null) {
                    final double[] actualValue = expensive();
                    value = actualValue == null ? this.cached : actualValue;
                    this.cached.set(value);
                }
            }
        }
        return (double[]) (value == this.cached ? null : value);
    }
    private double[] expensive() {
        double[] result = new double[1000000];
        for (int i = 0; i < result.length; i++) {
            result[i] = Math.asin(i);
        }
        return result;
    }
}*/

七、原理

7.1 原理分析

Java 的编译过程大致可以分为三个阶段

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

编译过程如下图所示

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

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

7.2 简易Lombok的Getter实现

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

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

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

7.2.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.zn.opit.lombokdemo.MyGetter")
public class MyGetterProcessor extends AbstractProcessor {

    private Messager messager; // 编译时期输入日志的
    private JavacTrees javacTrees; // 提供了待处理的抽象语法树
    private TreeMaker treeMaker; // 封装了创建AST节点的一些方法
    private Names names; // 提供了创建标识符的方法

    @Override
    public 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);
    }

    @Override
    public 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() {
                @Override
                public 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，如上代码所示。

---

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

@MyGetter
public class ZhiNian {
    private String name;
}

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

# 使用 tools.jar 编译自定义的注解器, 注 命令最后面有一个 . 表示当前文件夹
javac -cp $JAVA_HOME/lib/tools.jar MyGetter* -d .
# 使用自定义注解器，编译 ZhiNian 类
javac -processor com.zn.opit.lombokdemo.MyGetterProcessor ZhiNian.java
# 查看 ZhiNian 源码
javap -p ZhiNian.class

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

7.3 优缺点

优点: 让我们写更少的代码，节约了开发时间
缺点

降低了可调试性

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

可能会有兼容性问题

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

可能会影响团队协作

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

破坏了封装性

面向对象封装的定义是：通过访问权限控制，隐藏内部数据，外部仅能通过类提供的有限的接口访问和修改内部数据。

也就是说，我们不应该无脑的使用 Lombok 对外暴露所有字段的 Getter/Setter 方法，因为有些字段在某些情况下是不允许直接修改的，比如购物车中的商品数量，它直接影响了购物详情和总价，因此在修改的时候应该提供统一的方法，进行关联修改，而不是给每个字段添加访问和修改的方法。

7.4 小结

它是通过 JDK 6 实现的 JSR 269: Pluggable Annotation Processing API (编译期的注解处理器) ，在编译期时把 Lombok 的注解转换为 Java 的常规方法的，我们可以通过继承 AbstractProcessor 类，重写它的 init() 和 process() 方法，实现一个简易版的 Lombok。但同时 Lombok 也存在这一些使用上的缺点，比如：降低了可调试性、可能会有兼容性等问题，因此我们在使用时要根据自己的业务场景和实际情况，来选择要不要使用 Lombok，以及应该如何使用 Lombok。