Lombok之@Builder注解

前言

Lombok大家都知道，在使用POJO过程中，它给我们带来了很多便利，省下大量写get、set方法、构造器、equal、toString方法的时间。除此之外，通过@Builder注解，lombok还可以方便的实现建造者模式。

认识@Builder注解

lombok注解在java进行编译时进行代码的构建，对于java对象的创建工作它可以更优雅，不需要写多余的重复的代码，这对于JAVA开发人员是很重要的，在出现lombok之后，对象的创建工作更提供Builder方法，它提供在设计数据实体时，对外保持private setter，而对属性的赋值采用Builder的方式，这种方式最优雅，也更符合封装的原则，不对外公开属性的写操作！
@Builder声明实体，表示可以进行Builder方式初始化，@Value注解，表示只公开getter，对所有属性的setter都封闭，即private修饰，所以它不能和@Builder现起用

简单使用

在项目生成的实体类上，只需要我们添加@Builder注解即可。示例代码：

  1. package com.zy.pagehelper.model;
  3. import lombok.Builder;
  4. import lombok.Data;
  6. import java.io.Serializable;
  8. @Data
  9. @Builder
  10. public class Admin implements Serializable {
  12.     private Long id;
  14.     private String department;
  16.     private String email;
  18.     private String encodedpassword;
  20.     private String name;
  22.     private String username;
  24.     private static final long serialVersionUID = 1L;
  25. }

项目中使用。代码实例：

  1.  Admin admins =  Admin.builder()
  2.                       .id(admin.getId())
  3.                       .name(admin.getName())
  4.                       .email(admin.getEmail())
  5.                       .department(admin.getDepartment())
  6.                       .username(admin.getUsername())
  7.                       .build();

根据上面的示例，我们可以对@Builder注解有一个简单的认识。当我们向一个对象赋值的时候，可以通过@Builder注解类似于链式的调用对象进行赋值。它的主要优点就是可以优雅的给对象赋值，修改对象，省去了set方法来定义属性内容。

深入探究—原理

如果对建造者设计模式不太清楚的，可以先了解一下：建造者模式

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

  1.  Admin admins =  Admin.builder()
  2.                       .id(admin.getId())
  3.                       .name(admin.getName())
  4.                       .email(admin.getEmail())
  5.                       .department(admin.getDepartment())
  6.                       .username(admin.getUsername())
  7.                       .build();

@Builder可以放在类，构造器或方法上。虽然“基于类”和“基于构造器”模式是最常见的用例，但使用“方法”用例最容易解释。
被@Builder注解的方法（从现在开始称为target）将生成以下7件事：

  1. 一个内部静态类，名为FooBuilder，其类型参数与静态方法相同（称为builder）
  2. 在构建器中：目标的每个参数有一个私有的非静态非最终字段
  3. 在builder中：包私有的无参数空构造函数
  4. 在builder中：对目标的每个参数使用类似于“ setter”的方法：与该参数具有相同的类型和相同的名称。如上例所示，它返回构建器本身，以便可以将setter调用链接起来
  5. 在builder中：build()调用该方法的方法，并在每个字段中传递。它返回与目标返回相同的类型
  6. 有意义的toString()实现
  7. 在包含target的类中：一个builder()方法，该方法创建builder的新实例

下面我们通过class类，与我们上面的每一条进行对比：

  1. @Builder
  2. public class Card {
  3.     private int id;
  4.     private String name;
  5.     private boolean sex;
  6. }

使用@Builder注解反编译后的class类：

  1. public class Card {
  2.     private int id;
  3.     private String name;
  4.     private boolean sex;
  6.     Card(int id, String name, boolean sex) {
  7.         this.id = id;
  8.         this.name = name;
  9.         this.sex = sex;
  10.     }
  11.     //注解在编译后使得Card类中多了一个名为Card.CardBuilder的静态内部类
  12.     public static Card.CardBuilder builder() {
  13.         return new Card.CardBuilder();
  14.     }
  16.     public static class CardBuilder {
  17.         private int id;
  18.         private String name;
  19.         private boolean sex;
  21.         CardBuilder() {
  22.         }
  23.     //通过静态内部类，实现了name、sex、id等的属性方法
  24.     //其实这些方法和setAttribute十分类似，只是额外返回了实例本身，这使得它可以使用类似于链式调用的写法。
  25.         public Card.CardBuilder id(int id) {
  26.             this.id = id;
  27.             return this;
  28.         }
  30.         public Card.CardBuilder name(String name) {
  31.             this.name = name;
  32.             return this;
  33.         }
  35.         public Card.CardBuilder sex(boolean sex) {
  36.             this.sex = sex;
  37.             return this;
  38.         }
  39.     //build方法调用Card类的全参构造方法来生成Card实例
  40.     //Card类还是实现了builder方法，这个方法生成一个空的Card.CardBuilder实例。
  41.         public Card build() {
  42.             return new Card(this.id, this.name, this.sex);
  43.         }
  45.         public String toString() {
  46.             return "Card.CardBuilder(id=" + this.id + ", name=" + this.name + ", sex=" + this.sex + ")";
  47.         }
  48.     }
  49. }

使用@Builder注解有无继承

一、 无继承父类的情况

可以将@Builder注解直接放置在类上，示例代码：

  1. @Data
  2. @Builder
  3. public class Student {
  5.     private String schoolName;
  6.     private String grade;
  8.     public static void main(String[] args) {
  10.         Student student = Student.builder().schoolName("清华附小").grade("二年级").build();
  11.         // Student(schoolName=清华附小, grade=二年级)
  12.         System.out.println(student);
  13.     }
  14. }

二、有继承父类的情况

  1. 对于父类，使用@AllArgsConstructor注解
  2. 对于子类，手动编写全参数构造器，内部调用父类全参数构造器，在子类全参数构造器上使用@Builder注解
    通过这种方式，子类Builder对象可以使用父类的所有私有属性。但是这种解法也有两个副作用：
  • 因为使用@AllArgsConstructor注解，父类构造函数字段的顺序由声明字段的顺序决定，如果子类构造函数传参的时候顺序不一致，字段类型还一样的话，出了错不好发现
  • 如果父类字段有增减，所有子类的构造器都要修改

示例代码父类：

  1. @Data
  2. // 对于父类，使用@AllArgsConstructor注解
  3. @AllArgsConstructor
  4. public class Person {
  6.     private int weight;
  7.     private int height;
  8. }

示例代码子类：

  1. @Data
  2. @ToString(callSuper = true)
  3. public class Student extends Person {
  5.     private String schoolName;
  6.     private String grade;
  8. // 对于子类，手动编写全参数构造器，内部调用父类全参数构造器，在子类全参数构造器上使用@Builder注解
  9.     @Builder
  10.     public Student(int weight, int height, String schoolName, String grade) {
  11.         super(weight, height);
  12.         this.schoolName = schoolName;
  13.         this.grade = grade;
  14.     }
  16.     public static void main(String[] args) {
  18.         Student student = Student.builder().schoolName("清华附小").grade("二年级")
  19.                 .weight(10).height(10).build();
  21.         // Student(super=Person(weight=10, height=10), schoolName=清华附小, grade=二年级)
  22.         System.out.println(student.toString());
  23.     }
  24. }

@Builder注解导致默认值无效问题

@Builder注解导致默认值无效—-解决方案

看完上面的内容我们知道@Builder注解它可以让我们很方便的使用builder模式构建对象。但是当我们给对象赋有默认值的时候会被@Builder注解清除掉。
从下面一段代码中，我们可以更加清楚的认识到这一点：

  1. public class BuilderTest {
  2.     @lombok.Builder
  3.     @lombok.Data
  4.     private static class Builder {
  5.         private String name = "1232";
  6.     }
  8.     @Test
  9.     public void test() {
  10.         Builder builder = Builder.builder().build();
  11.         System.out.println(builder.getName());
  12.     }
  13. }
  14. ---打印结果---
  15. null

那么不想让这个默认值被清除，就只能用另外一个注解来对属性进行设置：@lombok.Builder.Default

  1. public class BuilderTest {
  2.     @lombok.Builder
  3.     @lombok.Data
  4.     private static class Builder {
  5.         @lombok.Builder.Default
  6.         private String name = "1232";
  7.     }
  9.     @Test
  10.     public void test() {
  11.         Builder builder = Builder.builder().build();
  12.         System.out.println(builder.getName());
  13.     }
  14. }
  15. ---打印结果---
  16. 1232
  • 需要注意的是@lombok.Builder.Default这个注解是后来才有的，目前已知的是1.2.X没有，1.6.X中有这个注解。

@Builder注解导致默认值无效——分析原因

由上面文章内容，我们可以知道，当我们使用**@Builder**注解时，编译后会生成一个静态内部类，通过静态内部类，最终才实现属性的方法，但是现实的方法，并不默认值，这就导致当我们builder之后的实体类的属性值是null。

示例代码：

  1. //编译前
  2. @lombok.Builder
  3. class Example {
  4.     private String name = "123";
  5. }
  6. //编译后class类
  7. class Example {
  8.     private String name;
  10.     private Example(String name) {
  11.         this.name = name;
  12.     }
  14.     public static ExampleBuilder builder() {
  15.         return new ExampleBuilder();
  16.     }
  18.     public static class ExampleBuilder {
  19.         private String name;
  21.         private ExampleBuilder() {}
  22.         //这里我们可以看到，静态内部类实现了属性方法，但是并没有对默认值做处理，
  23.         //所有builder之后返回的属性值为null
  24.         public ExampleBuilder name(String name) {
  25.             this.name = name;
  26.             return this;
  27.         }
  29.         @java.lang.Override public String toString() {
  30.             return "Example(name = " + name + ")";
  31.         }
  33.         public Example build() {
  34.             return new Example(name);
  35.         }
  36.     }
  37. }

推荐参考blog：@Builder注解构造器生成的详解

@Builder相关注解

@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("jdkong")
  5.                 .username("jdkong")
  6.                 .build();
  7.         System.out.println(user);
  8.     }
  9. }
  11. // 输出内容：
  12. User(id=416219e1-bc64-43fd-b2c3-9f8dc109c2e8, username=jdkong, password=jdkong, insertTime=1546869309868)

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

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

@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 "";
  25.         boolean isStatic() default false;
  26.     }
  27. }

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