1. 什么是Lombok？

官网：https://www.projectlombok.org/

安装插件和配置依赖

image.png
如上图所示，Lombok支持所有主流的 IDE 开发工具及编译构建工具。在 IDEA 中安装 Lombok 插件，这样在使用 Lombok 的时候就不会编译报错。

下面是 Maven 的依赖配置，在用 Maven 打包的时候也能自动生成需要的代码。

  1. <dependency>
  2.     <groupId>org.projectlombok</groupId>
  3.     <artifactId>lombok</artifactId>
  4.     <version>1.18.2</version>
  5.     <scope>provided</scope>
  6. </dependency>

如果你使用了 Spring Boot，可以不用带版本号，在 Spring Boot spring-boot-dependencies.pom 这个配置文件里面定义了 Lombok 依赖。

所以，你只需要继承版本号即可，当然，有必要的话，你也可以自定义版本号。

  1. <dependency>
  2.     <groupId>org.projectlombok</groupId>
  3.     <artifactId>lombok</artifactId>
  4.     <scope>provided</scope>
  5. </dependency>

2. 使用注解简化代码

从 IDEA 中的 Lombok 插件特性可以看到支持的注解。

  1. Features
  2. @Getter and @Setter
  3. @FieldNameConstants
  4. @ToString
  5. @EqualsAndHashCode
  6. @AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
  7. @Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger
  8. @Data
  9. @Builder
  10. @Singular
  11. @Delegate
  12. @Value
  13. @Accessors
  14. @Wither
  15. @SneakyThrows
  16. from Intellij 14.1 @val
  17. from Intellij 15.0.2 @var
  18. from Intellij 14.1 @var
  19. from Intellij 2016.2 @UtilityClass
  20. Lombok config system
  21. Code inspections
  22. Refactoring actions (lombok and delombok)

@Getter 和 @Setter

  1. @Getter
  2. @Setter
  3. public class User {
  4.   private String name;
  5.   private int age;
  6.   ...
  7.   // 无需生成 get/set 方法
  8. }

添加 @Getter 和 @Setter 注解用在 Java Bean 类上面，无需生成 get/ set 方法，会自动生成所有的 get/ set 方法及一个默认的构造方法。

@Getter 和 @Setter 注解也可以单独使用在字段上面，同样也会生成对应的 get/ set 方法及一个默认的构造方法。

@ToString

使用在类上，默认生成所有非静态字段以下面的格式输出，如：

  1. public String toString(){
  2.     return "Person(userName=" + getUserName() + ", id=" + getId() + ", age=" + getAge() + ", address=" + getAddress() + ", memo=" + getMemo() + ")";
  3. }

里面也有很多参数，用来自定义输出格式。

@NoArgsConstructor

用在类上，用来生成一个默认的无参构造方法。

@RequiredArgsConstructor

用在类上，使用类中所有带有 @NonNull 注解和 final 类型的字段生成对应的构造方法。

@AllArgsConstructor

用在类上，生成一个所有参数的构造方法，默认不提供无参构造方法。

@Data

用在类上，等同于下面这几个注解合集。

@Getter @Setter @RequiredArgsConstructor @ToString @EqualsAndHashCode

@Value

用在类上，等同于下面这几个注解合集。

@Getter @FieldDefaults(makeFinal=true, level=AccessLevel.PRIVATE) @AllArgsConstructor @ToString @EqualsAndHashCode}

@NonNull

用在属性上，用于字段的非空检查，如果传入到 set 方法中的值为空，则抛出空指针异常，该注解也会生成一个默认的构造方法。

@Accessors(chain = true) ：

链式风格

  1. @Accessors(chain = true)
  2. @Setter
  3. @Getter
  4. @RequiredArgsConstructor(staticName = "ofName")
  5. public class Student {
  6.     @NonNull private String name;
  7.     private int age;
  8. }

@Builder

基础使用

@Builder注释为你的类生成相对略微复杂的构建器API。@Builder可以让你以下面显示的那样调用你的代码，来初始化你的实例对象：

  1. Student.builder()
  2.     .sno( "001" )
  3.     .sname( "admin" )
  4.     .sage( 18 )
  5.     .sphone( "110" )
  6.     .build();

@Builder可以放在类，构造函数或方法上。 虽然放在类上和放在构造函数上这两种模式是最常见的用例，但@Builder最容易用放在方法的用例来解释。

@Builder内部帮我们做了什么？
  1. 创建一个名为ThisClassBuilder的内部静态类，并具有和实体类形同的属性（称为构建器）。
  2. 在构建器中：对于目标类中的所有的属性和未初始化的final字段，都会在构建器中创建对应属性。
  3. 在构建器中：创建一个无参的default构造函数。
  4. 在构建器中：对于实体类中的每个参数，都会对应创建类似于setter的方法，只不过方法名与该参数名相同。 并且返回值是构建器本身（便于链式调用），如上例所示。
  5. 在构建器中：一个build()方法，调用此方法，就会根据设置的值进行创建实体对象。
  6. 在构建器中：同时也会生成一个toString()方法。
  7. 在实体类中：会创建一个builder()方法，它的目的是用来创建构建器。

说这么多，不如让我们通过下面这个例子来理解：

  1. @Builder
  2. public class User {
  3.     private final Integer code = 200;
  4.     private String username;
  5.     private String password;
  6. }
  7. // 编译后：
  8. public class User {
  9.     private String username;
  10.     private String password;
  11.     User(String username, String password) {
  12.         this.username = username; this.password = password;
  13.     }
  14.     public static User.UserBuilder builder() {
  15.         return new User.UserBuilder();
  16.     }
  17.     public static class UserBuilder {
  18.         private String username;
  19.         private String password;
  20.         UserBuilder() {}
  21.         public User.UserBuilder username(String username) {
  22.             this.username = username;
  23.             return this;
  24.         }
  25.         public User.UserBuilder password(String password) {
  26.             this.password = password;
  27.             return this;
  28.         }
  29.         public User build() {
  30.             return new User(this.username, this.password);
  31.         }
  32.         public String toString() {
  33.             return "User.UserBuilder(username=" + this.username + ", password=" + this.password + ")";
  34.         }
  35.     }
  36. }

组合用法

1. @Builder中使用 @Singular 注释集合

@Builder也可以为集合类型的参数或字段生成一种特殊的方法。 它采用修改列表中一个元素而不是整个列表的方式，可以是增加一个元素，也可以是删除一个元素。

  1. Student.builder()
  2.     .sno( "001" )
  3.     .sname( "admin" )
  4.     .sage( 18 )
  5.     .sphone( "110" ).sphone( "112" )
  6.     .build();

这样就可以轻松地将List <String>字段中包含2个字符串。 但是想要这样来操作集合，你需要使用@Singular来注释字段或参数。

在使用@Singular注释注释一个集合字段（使用@Builder注释类），lombok会将该构建器节点视为一个集合，并生成两个adder方法而不是setter方法。

  • 一个向集合添加单个元素
  • 一个将另一个集合的所有元素添加到集合中

将不生成仅设置集合（替换已添加的任何内容）的setter。 还生成了clear方法。 这些singular构建器相对而言是有些复杂的，主要是来保证以下特性：

  1. 在调用build()时，生成的集合将是不可变的。
  2. 在调用build()之后调用其中一个adder方法或clear方法不会修改任何已经生成的对象。如果对集合修改之后，再调用build()，则会创建一个基于上一个对象创建的对象实体。
  3. 生成的集合将被压缩到最小的可行格式，同时保持高效。

@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注解之后的编译情况：

  1. @Builder
  2. public class User {
  3.     private final Integer id;
  4.     private final String zipCode = "123456";
  5.     private String username;
  6.     private String password;
  7.     @Singular
  8.     private List<String> hobbies;
  9. }
  10. // 编译后：
  11. public class User {
  12.     private final Integer id;
  13.     private final String zipCode = "123456";
  14.     private String username;
  15.     private String password;
  16.     private List<String> hobbies;
  17.     User(Integer id, String username, String password, List<String> hobbies) {
  18.         this.id = id; this.username = username;
  19.         this.password = password; this.hobbies = hobbies;
  20.     }
  21.     public static User.UserBuilder builder() {return new User.UserBuilder();}
  22.     public static class UserBuilder {
  23.         private Integer id;
  24.         private String username;
  25.         private String password;
  26.         private ArrayList<String> hobbies;
  27.         UserBuilder() {}
  28.         public User.UserBuilder id(Integer id) { this.id = id; return this; }
  29.         public User.UserBuilder username(String username) { this.username = username; return this; }
  30.         public User.UserBuilder password(String password) { this.password = password; return this; }
  31.         public User.UserBuilder hobby(String hobby) {
  32.             if (this.hobbies == null) {
  33.                 this.hobbies = new ArrayList();
  34.             }
  35.             this.hobbies.add(hobby);
  36.             return this;
  37.         }
  38.         public User.UserBuilder hobbies(Collection<? extends String> hobbies) {
  39.             if (this.hobbies == null) {
  40.                 this.hobbies = new ArrayList();
  41.             }
  42.             this.hobbies.addAll(hobbies);
  43.             return this;
  44.         }
  45.         public User.UserBuilder clearHobbies() {
  46.             if (this.hobbies != null) {
  47.                 this.hobbies.clear();
  48.             }
  49.             return this;
  50.         }
  51.         public User build() {
  52.             List hobbies;
  53.             switch(this.hobbies == null ? 0 : this.hobbies.size()) {
  54.             case 0:
  55.                 hobbies = Collections.emptyList();
  56.                 break;
  57.             case 1:
  58.                 hobbies = Collections.singletonList(this.hobbies.get(0));
  59.                 break;
  60.             default:
  61.                 hobbies = Collections.unmodifiableList(new ArrayList(this.hobbies));
  62.             }
  63.             return new User(this.id, this.username, this.password, hobbies);
  64.         }
  65.         public String toString() {
  66.             return "User.UserBuilder(id=" + this.id + ", username=" + this.username + ", password=" + this.password + ", hobbies=" + this.hobbies + ")";
  67.         }
  68.     }
  69. }

其实，lombok的创作者还是很用心的，在进行 build() 来创建实例对象时，
并没有直接使用Collections.unmodifiableList(Collection)此方法来床架实例，而是分为三种情况。

  • 第一种，当集合中没有元素时，创建一个空list
  • 第二种情况，当集合中存在一个元素时，创建一个不可变的单元素list
  • 第三种情况，根据当前集合的元素数量创建对应合适大小的list

当然我们看编译生成的代码，创建了三个关于集合操作的方法：

  • hobby(String hobby)：向集合中添加一个元素
  • hobbies(Collection<? extends String> hobbies)：添加一个集合所有的元素
  • clearHobbies()：清空当前集合数据

2. @Singular 注解配置value属性

我们先来看看 @Singular 注解的详情：

  1. @Target({FIELD, PARAMETER})
  2. @Retention(SOURCE)
  3. public @interface Singular {
  4.     // 修改添加集合元素的方法名
  5.     String value() default "";
  6. }
  • 测试如何使用注解属性value
  1. @Builder
  2. public class User {
  3.     private final Integer id;
  4.     private final String zipCode = "123456";
  5.     private String username;
  6.     private String password;
  7.     @Singular(value = "testHobbies")
  8.     private List<String> hobbies;
  9. }
  10. // 测试类
  11. public class BuilderTest {
  12.     public static void main(String[] args) {
  13.         User user = User.builder()
  14.                 .testHobbies("reading")
  15.                 .testHobbies("eat")
  16.                 .id(1)
  17.                 .password("admin")
  18.                 .username("admin")
  19.                 .build();
  20.         System.out.println(user);
  21.     }
  22. }

说明，当我们使用了注解属性value之后，我们在使用添加集合元素时的方法名发生相应的改变。但是，同时生成的添加整个集合的方法名发生改变了吗？我们再来看看编译后的代码：

  1. / 编译后：
  2. public class User {
  3.     // 省略部分代码，只看关键部分
  4.     public static class UserBuilder {
  5.         public User.UserBuilder testHobbies(String testHobbies) {
  6.             if (this.hobbies == null) {
  7.                 this.hobbies = new ArrayList();
  8.             }
  9.             this.hobbies.add(testHobbies);
  10.             return this;
  11.         }
  12.         public User.UserBuilder hobbies(Collection<? extends String> hobbies) {
  13.             if (this.hobbies == null) {
  14.                 this.hobbies = new ArrayList();
  15.             }
  16.             this.hobbies.addAll(hobbies);
  17.             return this;
  18.         }
  20.         public User.UserBuilder clearHobbies() {
  21.             if (this.hobbies != null) {
  22.                 this.hobbies.clear();
  23.             }
  24.             return this;
  25.         }
  26.     }
  27. }

可以看到，只有添加一个元素的方法名发生了改变。

3. @Builder.Default 的使用

比如有这样一个实体类：

  1. @Builder
  2. @ToString
  3. public class User {
  4.     @Builder.Default
  5.     private final String id = UUID.randomUUID().toString();
  6.     private String username;
  7.     private String password;
  8.     @Builder.Default
  9.     private long insertTime = System.currentTimeMillis();
  10. }

在类中我在id和insertTime上都添加注解@Builder.Default，当我在使用这个实体对象时，我就不需要在为这两个字段进行初始化值，如下面这样：

  1. public class BuilderTest {
  2.     public static void main(String[] args) {
  3.         User user = User.builder()
  4.                 .password("admin")
  5.                 .username("admin")
  6.                 .build();
  7.         System.out.println(user);
  8.     }
  9. }
  10. // 输出内容：
  11. User(id=416219e1-bc64-43fd-b2c3-9f8dc109c2e8, username=admin, password=admin, insertTime=1546869309868)

lombok在实例化对象时就为我们初始化了这两个字段值。
当然，你如果再对这两个字段进行设值的话，那么默认定义的值将会被覆盖掉，如下面这样：

  1. public class BuilderTest {
  2.     public static void main(String[] args) {
  3.         User user = User.builder()
  4.                 .id("admin")
  5.                 .password("admin")
  6.                 .username("admin")
  7.                 .build();
  8.         System.out.println(user);
  9.     }
  10. }
  11. // 输出内容
  12. User(id=admin, username=admin, password=admin, insertTime=1546869642151)

4. @Builder 详细配置

下面我们再来详细看看@Builder这个注解类地详细实现：

  1. @Target({TYPE, METHOD, CONSTRUCTOR})
  2. @Retention(SOURCE)
  3. public @interface Builder {
  4.     // 如果@Builder注解在类上，可以使用 @Builder.Default指定初始化表达式
  5.     @Target(FIELD)
  6.     @Retention(SOURCE)
  7.     public @interface Default {}
  8.     // 指定实体类中创建 Builder 的方法的名称，默认为: builder (个人觉得没必要修改)
  9.     String builderMethodName() default "builder";
  10.     // 指定 Builder 中用来构件实体类的方法的名称，默认为：build (个人觉得没必要修改)
  11.     String buildMethodName() default "build";
  12.     // 指定创建的建造者类的名称，默认为：实体类名+Builder
  13.     String builderClassName() default "";
  14.     // 使用toBuilder可以实现以一个实例为基础继续创建一个对象。（也就是重用原来对象的值）
  15.     boolean toBuilder() default false;
  17.     @Target({FIELD, PARAMETER})
  18.     @Retention(SOURCE)
  19.     public @interface ObtainVia {
  20.         // 告诉lombok使用表达式获取值
  21.         String field() default "";
  22.         // 告诉lombok使用表达式获取值
  23.         String method() default "";
  24.         boolean isStatic() default false;
  25.     }
  26. }

以上注解属性，我只测试一个比较常用的toBuilder，因为我们在对实体对象进行操作时，往往会存在对某些实体对象的某个字段进行二次赋值，这个时候就会用到这一属性。但是，这会创建一个新的对象，而不是原来的对象，原来的对象属性是不可变的，除非你自己想要给这个实体类再添加上@Data或者@setter方法。下面就来测试一下：

  1. @Builder(toBuilder = true)
  2. @ToString
  3. public class User {
  4.     private String username;
  5.     private String password;
  6. }
  7. // 测试类
  8. public class BuilderTest {
  9.     public static void main(String[] args) {
  10.         User user1 = User.builder()
  11.                 .password("admin")
  12.                 .username("admin")
  13.                 .build();
  14.         System.out.println(user1);
  15.         User user2 = user1.toBuilder().username("admin2").build();
  16.         // 验证user2是否是基于user1的现有属性创建的
  17.         System.out.println(user2);
  18.         // 验证对象是否是同一对象
  19.         System.out.println(user1 == user2);
  20.     }
  21. }
  22. // 输出内容
  23. User(username=admin, password=admin)
  24. User(username=admin2, password=admin)
  25. false

5. @Builder 全局配置
  1. # 是否禁止使用@Builder
  2. lombok.builder.flagUsage = [warning | error] (default: not set)
  3. # 是否使用Guaua
  4. lombok.singular.useGuava = [true | false] (default: false)
  5. # 是否自动使用singular，默认是使用
  6. lombok.singular.auto = [true | false] (default: true)