Java Lombok
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. }

组合用法

@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():清空当前集合数据

    @Singular 注解配置 value 属性

    先来看看 @Singular 注解的详情:

    1. @Target({FIELD, PARAMETER})
    2. @Retention(SOURCE)
    3. public @interface Singular {
    4. // 修改添加集合元素的方法名
    5. String value() default "";
    6. }
  • 测试如何使用注解属性value ```java @Builder public class User { private final Integer id; private final String zipCode = “123456”; private String username; private String password; @Singular(value \= “testHobbies”) private List hobbies; }

// 测试类 public class BuilderTest { public static void main(String[] args) { User user \= User.builder() .testHobbies(“reading”) .testHobbies(“eat”) .id(1) .password(“admin”) .username(“admin”) .build(); System.out.println(user); } }

  1. 说明,当使用了注解属性`value`之后,在使用添加集合元素时的方法名发生相应的改变。但是,同时生成的添加整个集合的方法名发生改变了吗?再来看看编译后的代码:
  2. ```java
  3. / 编译后:
  4. public class User {
  5. // 省略部分代码,只看关键部分
  6. public static class UserBuilder {
  7. public User.UserBuilder testHobbies(String testHobbies) {
  8. if (this.hobbies == null) {
  9. this.hobbies = new ArrayList();
  10. }
  11. this.hobbies.add(testHobbies);
  12. return this;
  13. }
  14. public User.UserBuilder hobbies(Collection<? extends String> hobbies) {
  15. if (this.hobbies == null) {
  16. this.hobbies = new ArrayList();
  17. }
  18. this.hobbies.addAll(hobbies);
  19. return this;
  20. }
  21. public User.UserBuilder clearHobbies() {
  22. if (this.hobbies != null) {
  23. this.hobbies.clear();
  24. }
  25. return this;
  26. }
  27. }
  28. }

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

@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. }

在类中在idinsertTime上都添加注解@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)

@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;
  16. @Target({FIELD, PARAMETER})
  17. @Retention(SOURCE)
  18. public @interface ObtainVia {
  19. // 告诉lombok使用表达式获取值
  20. String field() default "";
  21. // 告诉lombok使用表达式获取值
  22. String method() default "";
  23. boolean isStatic() default false;
  24. }
  25. }

以上注解属性,只测试一个比较常用的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

@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)

总的来说@Builder还是很好用的。