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

時間  2020-04-07
標籤 99% 程序員 都在 lombok 原理 居然 簡單 一個 建議 收藏 欄目 快樂工作 简体版
原文   原文鏈接
世界上只有一種英雄主義，就是看清生活的真相以後依然熱愛生活。

對於 Lombok 我相信大部分人都不陌生，但對於它的實現原理以及缺點卻不爲人知，而本文將會從 Lombok 的原理出發，手擼一個簡易版的 Lombok，讓你理解這個熱門技術背後的執行原理，以及它的優缺點分析。java

簡介

在講原理以前，咱們先來複習一下 Lombok (老司機可直接跳過本段)。git

Lombok 是一個很是熱門的開源項目 (https://github.com/rzwitserlo...，使用它能夠有效的解決 Java 工程中那些繁瑣又重複代碼，例如 Setter、Getter、toString、equals、hashCode 以及非空判斷等，均可以使用 Lombok 有效的解決。github

使用

1.添加 Lombok 插件

在 IDE 中必須安裝 Lombok 插件，才能正常調用被 Lombok 修飾的代碼，以 Idea 爲例，添加的步驟以下：apache

  • 點擊 File > Settings > Plugins 進入插件管理頁面
  • 點擊 Browse repositories...
  • 搜索 Lombok Plugin
  • 點擊 Install plugin 安裝插件
  • 重啓 IntelliJ IDEA

安裝完成，以下圖所示：
編程

2.添加 Lombok 庫

接下來咱們須要在項目中添加最新的 Lombok 庫，若是是 Maven 項目，直接在 pom.xml 中添加以下配置：api

<dependencies>
  <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

若是是 JDK 9+ 可以使用模塊的方式添加，配置以下：微信

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

3.使用 Lombok

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

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 以後的代碼：ide

@Getter
@Setter
public class Person {
    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<String>();  
// 至關於
final Set<String> 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)
public class LombokDemo {
    private int id;
    private String shap;
}

⑦ NoArgsConstructor、RequiredArgsConstructor、AllArgsConstructor 使用

@NoArgsConstructor
@RequiredArgsConstructor(staticName = "of")
@AllArgsConstructor
public class LombokDemo {
    @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;
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;
    }
}

原理分析

咱們知道 Java 的編譯過程大體能夠分爲三個階段：

  1. 解析與填充符號表
  2. 註解處理
  3. 分析與字節碼生成

編譯過程以下圖所示：
編譯流程.png
而 Lombok 正是利用「註解處理」這一步進行實現的，Lombok 使用的是 JDK 6 實現的 JSR 269: Pluggable Annotation Processing API (編譯期的註解處理器) ，它是在編譯期時把 Lombok 的註解代碼，轉換爲常規的 Java 方法而實現優雅地編程的。

這一點能夠在程序中獲得驗證，好比本文剛開始用 @Data 實現的代碼：
image.png

在咱們編譯以後，查看 Person 類的編譯源碼發現，代碼居然是這樣的：
Person 生成的源碼.png
能夠看出 Person 類在編譯期被註解翻譯器修改爲了常規的 Java 方法，添加 Getter、Setter、equals、hashCode 等方法。

Lombok 的執行流程以下：
lombok 執行流程.png
能夠看出，在編譯期階段，當 Java 源碼被抽象成語法樹 (AST) 以後，Lombok 會根據本身的註解處理器動態的修改 AST，增長新的代碼 (節點)，在這一切執行以後，再經過分析生成了最終的字節碼 (.class) 文件，這就是 Lombok 的執行原理。

手擼一個 Lombok

咱們實現一個簡易版的 Lombok 自定義一個 Getter 方法，咱們的實現步驟是：

  1. 自定義一個註解標籤接口，並實現一個自定義的註解處理器；
  2. 利用 tools.jar 的 javac api 處理 AST (抽象語法樹)
  3. 使用自定義的註解處理器編譯代碼。

這樣就能夠實現一個簡易版的 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
public class Person {
    private String name;
}

2.使用自定義的註解處理器編譯代碼

上面的全部流程執行完成以後，咱們就能夠編譯代碼測試效果了。
首先，咱們先進入代碼的根目錄，執行如下三條命令。

進入的根目錄以下：
image.png
① 使用 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

源碼文件以下：
image.png

能夠看到咱們自定義的 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。

最後提醒一句，再好的技術也不是萬金油，就好像再好的鞋子也得適合本身的腳才行！

感謝閱讀，但願本文對你能所啓發。以爲不錯的話，分享給須要的朋友，謝謝。

參考 & 鳴謝

http://www.javashuo.com/article/p-ogmtxqdq-da.html
https://www.tuicool.com/articles/y6rUz2V

更多精彩內容，請關注微信公衆號「Java中文社羣」

Java中文社羣公衆號二維碼.jpg

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程