定义：

  • 指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

    特点：

  • 各个具体的建造者相互独立，有利于系统的扩展。(优点)

  • 客户端不必知道产品内部组成的细节，便于控制细节风险。(优点)
  • 产品的组成部分必须相同，这限制了其使用范围。(缺点)

  • 如果产品的内部变化复杂，该模式会增加很多的建造者类。(缺点)

    通常适用场景：

  • 创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。

  • 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。

    demo代码：

  • 中规中矩的建造者模式

    1. public class User {
    2.   private String name;
    3.   private String password;
    4.   private String nickName;
    5.   private int age;
    7.   private User(String name, String password, String nickName, int age) {
    8.       this.name = name;
    9.       this.password = password;
    10.       this.nickName = nickName;
    11.       this.age = age;
    12.   }
    14.   public static UserBuilder builder() {
    15.       return new UserBuilder();
    16.   }
    18.   public static class UserBuilder {
    19.       private String  name;
    20.       private String password;
    21.       private String nickName;
    22.       private int age;
    24.       private UserBuilder() {
    25.       }
    27.       public UserBuilder name(String name) {
    28.           this.name = name;
    29.           return this;
    30.       }
    32.       public UserBuilder password(String password) {
    33.           this.password = password;
    34.           return this;
    35.       }
    37.       public UserBuilder nickName(String nickName) {
    38.           this.nickName = nickName;
    39.           return this;
    40.       }
    42.       public UserBuilder age(int age) {
    43.           this.age = age;
    44.           return this;
    45.       }
    47.       public User build() {
    48.           return new User(name, password, nickName, age);
    49.       }
    50.   }
    51. }

  • 注解版（使用lombok @Builder）

    1. @Builder
    2. class User {
    3.   private String  name;
    4.   private String password;
    5.   private String nickName;
    6.   private int age;
    7. }

  • 只想用链式写法，不要建造者模式（使用lombok @Accessors(chain = true) 和 @Data） ```java @Accessors(chain = true) @Data public class User { private String name; private String password; private String nickName; private int age;

} public void main(String[] args) { User user= new User().setName(“张三”).setNickName(“小张”).setPassword(“123456”).setAge(18); }

  2. - 测试
  3. ```java
  4. public static void main(String[] args) {
  5.     User user = User.builder()
  6.         .name("张三")
  7.         .nickName("小张")
  8.         .password("123456")
  9.         .age(18)
  10.         .build();
  11.   }