使用Lombok插件需要注意的問題

一、@Data注解

@Data注解相當於@Getter @Setter @RequiredArgsConstructor @ToString @EqualsAndHashCode這5個注解的合集。

通過官方文檔，可以得知，當使用@Data注解時，則有了@EqualsAndHashCode注解，那么就會在此類中存在equals(Object other) 和 hashCode()方法，且不會使用父類的屬性。

如果兩個對象的屬性相同，就會認為這兩個對象相等，即重寫了hashCode和equls方法。

解決：

　　使用@Getter @Setter 代替@Data 或者在該類中重寫equals與hashcode方法。

　　或者：顯式使用@EqualsAndHashCode(callSuper = true)。lombok會以顯式指定的為准。

　　需要注意的是：如果使用@Data 注解，那么使用Set集合去重機制也會受到影響。因為Set集合去重原理底層就是用的hashmap集合。由於hashcode與equals方法已經被重寫，所以會即使是兩個new出來的不同的對象，但是屬性相同的情況下也會返回true。

SysUserEntity user1 = new SysUserEntity(1,"張三",0);
SysUserEntity user2 = new SysUserEntity(1,"張三",0);    

詳細解釋：

原文中提到的大致有以下幾點：
1. 此注解會生成 equals(Object other) 和 hashCode() 方法。
2. 它默認使用非靜態，非瞬態的屬性
3. 可通過參數 exclude 排除一些屬性
4. 可通過參數 of 指定僅使用哪些屬性
5. 它默認僅使用該類中定義的屬性且不調用父類的方法
6. 可通過 callSuper=true 解決上一點問題。讓其生成的方法中調用父類的方法。

另：@Data 相當於 @Getter @Setter @RequiredArgsConstructor @ToString @EqualsAndHashCode 這5個注解的合集。

通過官方文檔，可以得知，當使用 @Data 注解時，則有了 @EqualsAndHashCode 注解，那么就會在此類中存在 equals(Object other) 和 hashCode() 方法，且不會使用父類的屬性，這就導致了可能的問題。
比如，有多個類有相同的部分屬性，把它們定義到父類中，恰好id（數據庫主鍵）也在父類中，那么就會存在部分對象在比較時，它們並不相等，卻因為lombok自動生成的 equals(Object other) 和 hashCode() 方法判定為相等，從而導致出錯。

修復此問題的方法很簡單：
1. 使用 @Getter @Setter @ToString 代替 @Data 並且自定義 equals(Object other) 和 hashCode() 方法，比如有些類只需要判斷主鍵id是否相等即足矣。
2. 或者使用在使用 @Data 時同時加上 @EqualsAndHashCode(callSuper=true) 注解。

---

看看下面的測試：

父類 TV.java 和 子類 小米TV.java，使用注解@EqualsAndHashCode(callSuper = false) 

小米tv繼承tv，從繼承角度講tv有的屬性，小米tv也是有的。

public class EqualsAndHashCodeTest {
    public static void main(String[] args) {
        XiaoMiTV tv1 = new XiaoMiTV("123", "lxk", 1L, "白");
        XiaoMiTV tv2 = new XiaoMiTV("456", "sql", 1L, "白");
        System.out.println(tv1.equals(tv2));
    }
}

　　因為在子類里面這么使用@EqualsAndHashCode(callSuper = false) ，不調用父類的屬性，那么子類屬性里面的相同則判斷相同。

　　把@EqualsAndHashCode(callSuper = false) 的false改成true

因為比較了字類的屬性和父類的屬性。

把@EqualsAndHashCode(callSuper = false) 這個語句注釋會怎么樣

所以默認是不管從父類繼承的屬性。

二、@Builder注解的使用

1、初入認識

如果對建造者設計模式不太清楚的，可以先了解一下：建造者模式

java設計模式——Builder（建造者模式（生成器模式））

@Builder注釋為你的類生成相對略微復雜的構建器API。@Builder可以讓你以下面顯示的那樣調用你的代碼，來初始化你的實例對象：

Person.builder()
    .name("Adam Savage")
    .city("San Francisco")
    .job("Mythbusters")
    .job("Unchained Reaction")
    .build();

@Builder可以放在類，構造函數或方法上。 雖然放在類上和放在構造函數上這兩種模式是最常見的用例，但@Builder最容易用放在方法的用例來解釋。

使用@Builder注釋的方法可以幫助我們完成一下一些事情：

• 一個名為xxxBuilder的內部靜態類，並具有和實體類形同的屬性（稱為構建器）。

• 在構建器中：對於目標類中的所有的屬性和未初始化的final字段，都會在構建器中創建對應屬性；

• 在構建器中：創建一個無參的default構造函數。

• 在構建器中：對於實體類中的每個參數，都會對應創建類似於“setter”的方法，只不多方法名與該參數名相同。 並且返回值是構建器本身（便於鏈式調用），如上例所示。

• 在構建器中：一個build()方法，調用此方法，就會根據設置的值進行創建實體對象。

• 在構建器中：同時也會生成一個toString()方法。

• 在實體類中：會創建一個builder()方法，它的目的是用來創建構建器。

@Builder
public class User {
    private String username;
    private String password;
}

// 編譯后：
public class User {
    private String username;
    private String password;
    User(String username, String password) {
        this.username = username; this.password = password;
    }
    public static User.UserBuilder builder() {
        return new User.UserBuilder();
    }

    public static class UserBuilder {
        private String username;
        private String password;
        UserBuilder() {}

        public User.UserBuilder username(String username) {
            this.username = username;
            return this;
        }
        public User.UserBuilder password(String password) {
            this.password = password;
            return this;
        }
        public User build() {
            return new User(this.username, this.password);
        }
        public String toString() {
            return "User.UserBuilder(username=" + this.username + ", password=" + this.password + ")";
        }
    }
}

2、@Builder 中使用 @Singular 注釋集合

@Builder也可以為集合類型的參數或字段生成一種特殊的方法。 它采用修改列表中一個元素而不是整個列表的方式，可以是增加一個元素，也可以是刪除一個元素。 例如：

Person.builder()
    .job("Mythbusters")
    .job("Unchained Reaction")
    .build();

這樣就可以輕松地將List <String>字段中包含2個字符串。 但是想要這樣來操作集合，你需要使用@Singular來注釋字段或參數。

在使用@Singular注釋注釋一個集合字段（使用@Builder注釋類），lombok會將該構建器節點視為一個集合，並生成兩個adder方法而不是setter方法。

• 一個向集合添加單個元素，

• 一個將另一個集合的所有元素添加到集合中。

將不生成僅設置集合（替換已添加的任何內容）的setter。 還生成了clear方法。 這些singular構建器相對而言是有些復雜的，主要是來保證以下特性：

• 在調用build()時，生成的集合將是不可變的。

• 在調用build()之后調用其中一個adder方法或clear方法不會修改任何已經生成的對象。如果對集合修改之后，再調用build()，則會創建一個基於上一個對象創建的對象實體。

• 生成的集合將被壓縮到最小的可行格式，同時保持高效。

@Singular只能應用於lombok已知的集合類型。目前，支持的類型有：

• java.util:

　　　　Iterable, Collection, 和List (一般情況下，由壓縮的不可修改的ArrayList支持).
　　　　Set, SortedSet, and NavigableSet (一般情況下，生成可變大小不可修改的HashSet或者TreeSet).
　　　　Map, SortedMap, and NavigableMap (一般情況下，生成可變大小不可修改的HashMap或者TreeMap).

• Guava’s com.google.common.collect:

　　　　ImmutableCollection and ImmutableList
　　　　ImmutableSet and ImmutableSortedSet
　　　　ImmutableMap, ImmutableBiMap, and ImmutableSortedMap
　　　　ImmutableTable
再來看看使用了@Singular注解之后的編譯情況：

@Builder
public class User {
    private final Integer id;
    private final String zipCode = "215500";
    private String username;
    private String password;
    @Singular
    private List<String> hobbies;
}

// 編譯后：
public class User {
    private final Integer id;
    private final String zipCode = "215500";
    private String username;
    private String password;
    private List<String> hobbies;
    User(Integer id, String username, String password, List<String> hobbies) {
        this.id = id; this.username = username;
        this.password = password; this.hobbies = hobbies;
    }

    public static User.UserBuilder builder() {return new User.UserBuilder();}

    public static class UserBuilder {
        private Integer id;
        private String username;
        private String password;
        private ArrayList<String> hobbies;
        UserBuilder() {}
        public User.UserBuilder id(Integer id) { this.id = id; return this; }
        public User.UserBuilder username(String username) { this.username = username; return this; }
        public User.UserBuilder password(String password) { this.password = password; return this; }

        public User.UserBuilder hobby(String hobby) {
            if (this.hobbies == null) {
                this.hobbies = new ArrayList();
            }
            this.hobbies.add(hobby);
            return this;
        }

        public User.UserBuilder hobbies(Collection<? extends String> hobbies) {
            if (this.hobbies == null) {
                this.hobbies = new ArrayList();
            }
            this.hobbies.addAll(hobbies);
            return this;
        }

        public User.UserBuilder clearHobbies() {
            if (this.hobbies != null) {
                this.hobbies.clear();
            }
            return this;
        }

        public User build() {
            List hobbies;
            switch(this.hobbies == null ? 0 : this.hobbies.size()) {
            case 0:
                hobbies = Collections.emptyList();
                break;
            case 1:
                hobbies = Collections.singletonList(this.hobbies.get(0));
                break;
            default:
                hobbies = Collections.unmodifiableList(new ArrayList(this.hobbies));
            }
            return new User(this.id, this.username, this.password, hobbies);
        }
        public String toString() {
            return "User.UserBuilder(id=" + this.id + ", username=" + this.username + ", password=" + this.password + ", hobbies=" + this.hobbies + ")";
        }
    }
}

其實，lombok的創作者還是很用心的，在進行build()來床建實例對象時，並沒有直接使用Collections.unmodifiableList(Collection)此方法來床架實例，而是分為三種情況：

• 第一種，當集合中沒有元素時，創建一個空list；

• 第二種情況，當集合中存在一個元素時，創建一個不可變的單元素list；

• 第三種情況，根據當前集合的元素數量創建對應合適大小的list；

當然我們看編譯生成的代碼，創建了三個關於集合操作的方法：

• hobby(String hobby)：向集合中添加一個元素

• hobbies(Collection<? extends String> hobbies)：添加一個集合所有的元素

• clearHobbies()：清空當前集合數據

3、@Singular 注解配置詳解

我們先來看看 @Singular 注解的詳情：

@Target({FIELD, PARAMETER})
@Retention(SOURCE)
public @interface Singular {
    // 修改添加集合元素的方法名
    String value() default "";
}

測試如何使用注解屬性vlaue

@Builder
public class User {
    private final Integer id;
    private final String zipCode = "215500";
    private String username;
    private String password;
    @Singular(value = "testHobbies")
    private List<String> hobbies;
}

// 測試類
public class BuilderTest {
    public static void main(String[] args) {
        User user = User.builder()
                .testHobbies("reading")
                .testHobbies("chatting")
                .id(1)
                .password("jdkong")
                .username("jdkong")
                .build();
        System.out.println(user);
    }
}

說明，當我們使用了注解屬性value之后，我們在使用添加集合元素時的方法名發生相應的改變。但是，同時生成的添加整個集合的方法名發生改變了嗎？我們再來看看編譯后的代碼：

// 編譯后：
public class User {
    // 省略部分代碼，只看關鍵部分
    public static class UserBuilder {
        public User.UserBuilder testHobbies(String testHobbies) {
            if (this.hobbies == null) {
                this.hobbies = new ArrayList();
            }
            this.hobbies.add(testHobbies);
            return this;
        }

        public User.UserBuilder hobbies(Collection<? extends String> hobbies) {
            if (this.hobbies == null) {
                this.hobbies = new ArrayList();
            }
            this.hobbies.addAll(hobbies);
            return this;
        }
        
        public User.UserBuilder clearHobbies() {
            if (this.hobbies != null) {
                this.hobbies.clear();
            }
            return this;
        }
    }
}

可以看到，只有添加一個元素的方法名發生了改變。

4、@Builder.Default 使用

比如有這樣一個實體類：

@Builder
@ToString
public class User {
    @Builder.Default
    private final String id = UUID.randomUUID().toString();
    private String username;
    private String password;
    @Builder.Default
    private long insertTime = System.currentTimeMillis();
}

 在類中我在id和insertTime上都添加注解@Builder.Default，當我在使用這個實體對象時，我就不需要在為這兩個字段進行初始化值，如下面這樣：

public class BuilderTest {
    public static void main(String[] args) {
        User user = User.builder()
                .password("jdkong")
                .username("jdkong")
                .build();
        System.out.println(user);
    }
}

// 輸出內容：
User(id=416219e1-bc64-43fd-b2c3-9f8dc109c2e8, username=jdkong, password=jdkong, insertTime=1546869309868)

lombok在實例化對象時就為我們初始化了這兩個字段值。

當然，你如果再對這兩個字段進行設值的話，那么默認定義的值將會被覆蓋掉，如下面這樣：

public class BuilderTest {
    public static void main(String[] args) {
        User user = User.builder()
                .id("jdkong")
                .password("jdkong")
                .username("jdkong")
                .build();
        System.out.println(user);
    }
}
// 輸出內容
User(id=jdkong, username=jdkong, password=jdkong, insertTime=1546869642151)

5、@Builder 詳細配置

下面我們再來詳細看看@Builder這個注解類地詳細實現：

@Target({TYPE, METHOD, CONSTRUCTOR})
@Retention(SOURCE)
public @interface Builder {
    // 如果@Builder注解在類上，可以使用 @Builder.Default指定初始化表達式
    @Target(FIELD)
    @Retention(SOURCE)
    public @interface Default {}
    // 指定實體類中創建 Builder 的方法的名稱，默認為: builder (個人覺得沒必要修改)
    String builderMethodName() default "builder";
    // 指定 Builder 中用來構件實體類的方法的名稱，默認為：build (個人覺得沒必要修改)
    String buildMethodName() default "build";
    // 指定創建的建造者類的名稱，默認為：實體類名+Builder
    String builderClassName() default "";
    // 使用toBuilder可以實現以一個實例為基礎繼續創建一個對象。（也就是重用原來對象的值）
    boolean toBuilder() default false;
    
    @Target({FIELD, PARAMETER})
    @Retention(SOURCE)
    public @interface ObtainVia {
        // 告訴lombok使用表達式獲取值
        String field() default "";
        // 告訴lombok使用表達式獲取值
        String method() default "";

        boolean isStatic() default false;
    }
}

　　以上注解屬性，我只測試一個比較常用的toBuilder，因為我們在對實體對象進行操作時，往往會存在對某些實體對象的某個字段進行二次賦值，這個時候就會用到這一屬性。但是，這會創建一個新的對象，而不是原來的對象，原來的對象屬性是不可變的，除非你自己想要給這個實體類再添加上@Data或者@setter方法（我是這么干過，哈哈）。下面就來測試一下：

@Builder(toBuilder = true)
@ToString
public class User {
    private String username;
    private String password;
}
// 測試類
public class BuilderTest {
    public static void main(String[] args) {
        User user1 = User.builder()
                .password("jdkong")
                .username("jdkong")
                .build();
        System.out.println(user1);

        User user2 = user1.toBuilder().username("jdkong2").build();
        // 驗證user2是否是基於user1的現有屬性創建的
        System.out.println(user2);
        // 驗證對象是否是同一對象
        System.out.println(user1 == user2);
    }
}
// 輸出內容
User(username=jdkong, password=jdkong)
User(username=jdkong2, password=jdkong)
false

6、@Builder注解對初始化的影響

先上結論：

　　如果類中用了@Builder注解，而屬性沒有任何注解話，那么在你初始化這個類的時候，如果你的屬性賦值了默認值，則在你初始化該類后，屬性的默認值則無效即獲取會產生空指針異常。

接下來我們來看看這中間發生了什么

　　從上面的例子，可以發現Teacher 的address屬性為空，這正是我們很常規初始化操作，獲取這個address，接着對它進行操作， 如果此時它是null，則會出現空指針異常；
　　比較Student中的address則是我們理想中的正常執行過程，是有一個默認值的對象，同時觀察Student中的name 和age兩個屬性值默認值也出現了如同Teacher中的address現象，默認值消失了；

　　從表面來看，Student多了@Builder.Default的注解，這個注解確實就是解決這個問題關鍵，讓你想要賦值的默認值來進行正確的初始化了。知道了這個注解的使用只是做到了知其然，我們要做做知其所以然，所以來看看下他們生成的class有什么區別？ 以下代碼反編譯刪除了equal和hashcode方法。

Teacher.class

public class Teacher {
private String name;
private List<String> address = new ArrayList();

Teacher(String name, List<String> address) {
    this.name = name;
    this.address = address;
}

public static Teacher.TeacherBuilder builder() {
    return new Teacher.TeacherBuilder();
}

public String getName() {
    return this.name;
}

public List<String> getAddress() {
    return this.address;
}

public void setName(String name) {
    this.name = name;
}
public void setAddress(List<String> address) {
    this.address = address;
}
protected boolean canEqual(Object other) {
    return other instanceof Teacher;
}

public String toString() {
    return "Teacher(name=" + this.getName() + ", address=" + this.getAddress() + ")";
}

public static class TeacherBuilder {
    private String name;
    private List<String> address;

    TeacherBuilder() {
    }

    public Teacher.TeacherBuilder name(String name) {
        this.name = name;
        return this;
    }

    public Teacher.TeacherBuilder address(List<String> address) {
        this.address = address;
        return this;
    }

    public Teacher build() {
        return new Teacher(this.name, this.address);
    }

    public String toString() {
        return "Teacher.TeacherBuilder(name=" + this.name + ", address=" + this.address + ")";
    }
}

Student.class

public class Student {
private String name = "c";
private int age = 25;
private long num;
private List<String> address;

private static List<String> $default$address() {
    return new ArrayList();
}

Student(String name, int age, long num, List<String> address) {
    this.name = name;
    this.age = age;
    this.num = num;
    this.address = address;
}

public static Student.StudentBuilder builder() {
    return new Student.StudentBuilder();
}

public String getName() {
    return this.name;
}

public int getAge() {
    return this.age;
}

public long getNum() {
    return this.num;
}

public List<String> getAddress() {
    return this.address;
}

public void setName(String name) {
    this.name = name;
}

public void setAge(int age) {
    this.age = age;
}

public void setNum(long num) {
    this.num = num;
}

public void setAddress(List<String> address) {
    this.address = address;
}
protected boolean canEqual(Object other) {
    return other instanceof Student;
}

  public String toString() {
    return "Student(name=" + this.getName() + ", age=" + this.getAge() + ", num=" + this.getNum() + ", address=" + this.getAddress() + ")";
}

public static class StudentBuilder {
    private String name;
    private int age;
    private long num;
    private boolean address$set;
    private List<String> address;

    StudentBuilder() {
    }

    public Student.StudentBuilder name(String name) {
        this.name = name;
        return this;
    }

    public Student.StudentBuilder age(int age) {
        this.age = age;
        return this;
    }

    public Student.StudentBuilder num(long num) {
        this.num = num;
        return this;
    }

    public Student.StudentBuilder address(List<String> address) {
        this.address = address;
        this.address$set = true;
        return this;
    }

    public Student build() {
        List address = this.address;
        if(!this.address$set) {
            address = Student.$default$address();
        }

        return new Student(this.name, this.age, this.num, address);
    }

    public String toString() {
        return "Student.StudentBuilder(name=" + this.name + ", age=" + this.age + ", num=" + this.num + ", address=" + this.address + ")";
    }
}

　　看兩個類的build方法，Student類在調用builde方法時，會判斷this.address$set 這個變量是否為false，如果為false，則為這個address對象進行賦值默認值，這個變量就是由@Builder.Default注解產生的.
　　而如果你直接對address方法進行賦值話，則會將這個this.address$set進行賦值，這樣調用build方法時，就不會再對address進行賦值了.
　　比較Teacher，沒有對address屬性增加@Builder.Default注解，所以在調用build方法時候，就不會產生判斷是否要對address進行默認值的初始化了，所以你獲取到的address就是null。

7、lombok 子類中如何使用@Builder

在使用@Builder過程中，有一個問題：子類的Builder對象沒有父類的屬性。這在使用上造成了一定的問題。

幾番搜索，對於這個問題，找到了如下解法，解法的鏈接會放到文末。 

1. 對於父類，使用@AllArgsConstructor注解 
2. 對於子類，手動編寫全參數構造器，內部調用父類全參數構造器，在子類全參數構造器上使用@Builder注解。

通過這種方式，子類Builder對象可以使用父類的所有私有屬性。

但是這種解法也有兩個副作用： 
1. 因為使用AllArgsConstructor注解，父類構造函數字段的順序由聲明字段的順序決定，如果子類構造函數傳參的時候順序不一致，字段類型還一樣的話，出了錯不好發現 。
2. 如果父類字段有增減，所有子類的構造器都要修改。

雖然有這兩個副作用，但是這種解法是我找到的唯一一種解決子類使用@Builder，能使用父類屬性的方式。

參考博客： 
Lombok’s @Builder annotation and inheritance 
副作用見博客評論

8、@Builder 全局配置

# 是否禁止使用@Builder
lombok.builder.flagUsage = [warning | error] (default: not set)
#是否使用Guaua
lombok.singular.useGuava = [true | false] (default: false)
# 是否自動使用singular，默認是使用
lombok.singular.auto = [true | false] (default: true)

 

 

 

參考文章：

https://www.jianshu.com/p/4e4cef2e82e1

https://blog.csdn.net/lqadam/article/details/82719841

https://blog.csdn.net/weixin_41540822/article/details/86606562