99%的程式員都在用Lombok，原理竟然這麼簡單？我也手撸了一個！|建議收藏！！！

對于 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

安裝完成，如下圖所示：

2.添加 Lombok 庫

接下來我們需要在項目中添加最新的 Lombok 庫，如果是 Maven 項目，直接在 pom.xml 中添加如下配置：

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

如果是 JDK 9+ 可使用子產品的方式添加，配置如下：

<path>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.12</version>
</path>

3.使用 Lombok

接下來到了前半部分中最重要的 Lombok 使用環節了，我們先來看在沒有使用 Lombok 之前的代碼：

public class Person {

private Integer id;
private String name;
public Integer getId() {
    return id;
}
public void setId(Integer id) {
    this.id = id;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}

}

這是使用 Lombok 之後的代碼：

@Getter

@Setter

private Integer id;
private String name;

可以看出在 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 或 $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 使用

val sets = new HashSet();

// 相當于

final Set sets = new HashSet<>();

② NonNull 使用

public void notNullExample(@NonNull String string) {

string.length();

public void notNullExample(String string) {

if (string != null) {
    string.length();
} else {
    throw new NullPointerException("null");
}

③ Cleanup 使用

public static void main(String[] args) {

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();
        }
    }
}

④ Getter/Setter 使用

@Setter(AccessLevel.PUBLIC)

@Getter(AccessLevel.PROTECTED)

private int id;

private String shap;

⑤ ToString 使用

@ToString(exclude = "id", callSuper = true, includeFieldNames = true)

public class LombokDemo {

private int id;
private String name;
private int age;
public static void main(String[] args) {
    // 輸出 LombokDemo(super=LombokDemo@48524010, name=null, age=0)
    System.out.println(new LombokDemo());
}

⑥ EqualsAndHashCode 使用

@EqualsAndHashCode(exclude = {"id", "shape"}, callSuper = false)

private int id;
private String shap;

⑦ NoArgsConstructor、RequiredArgsConstructor、AllArgsConstructor 使用

@NoArgsConstructor

@RequiredArgsConstructor(staticName = "of")

@AllArgsConstructor

@NonNull
private int id;
@NonNull
private String shap;
private int age;
public static void main(String[] args) {
    new LombokDemo(1, "Java");
    // 使用靜态工廠方法
    LombokDemo.of(2, "Java");
    // 無參構造
    new LombokDemo();
    // 包含所有參數
    new LombokDemo(1, "Java", 2);
}

⑧ Builder 使用

@Builder

public class BuilderExample {

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

⑨ 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();
}

⑩ 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");
    }
}

⑪ Getter(lazy = true) 使用

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;

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;
}

原理分析

我們知道 Java 的編譯過程大緻可以分為三個階段：

解析與填充符号表

注解處理

分析與位元組碼生成

編譯過程如下圖所示：

而 Lombok 正是利用「注解處理」這一步進行實作的，Lombok 使用的是 JDK 6 實作的 JSR 269: Pluggable Annotation Processing API (編譯期的注解處理器) ，它是在編譯期時把 Lombok 的注解代碼，轉換為正常的 Java 方法而實作優雅地程式設計的。

這一點可以在程式中得到驗證，比如本文剛開始用 @Data 實作的代碼：

在我們編譯之後，檢視 Person 類的編譯源碼發現，代碼竟然是這樣的：

可以看出 Person 類在編譯期被注解翻譯器修改成了正常的 Java 方法，添加 Getter、Setter、equals、hashCode 等方法。

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; // 提供了建立辨別符的方法

@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，如上代碼所示。

當這些代碼寫好之後，我們就可以新增一個 Person 類來試一下我們自定義的 @MyGetter 功能了，代碼如下：

@MyGetter

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 優缺點

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]

(

https://juejin.im/post/5a6eceb8f265da3e467555fe) https://www.tuicool.com/articles/y6rUz2V

原文位址

https://www.cnblogs.com/vipstone/p/12597756.html

99%的程式員都在用Lombok，原理竟然這麼簡單？我也手撸了一個！|建議收藏！！！

繼續閱讀

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

maven No compiler is provided in this environment. Perhaps you are running on a JRE rather than a J

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

面試題解析：你接口測試是怎麼做的？

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method

Opendaylight課堂之深度剖析toaster（一）