设计模式-建造者模式（Builder）

设计模式-建造者模式（Builder）

   概要

   记忆关键词：类和构造分离

   定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

   分析：

   1）当一个类的构造函数参数个数超过4个，而且这些参数有些是可选的参数，考虑使用构造者模式。

   2）构建者模式的精髓是将复杂对象的构建过程封装到构建者里，使用构建者再去创建对象，即先有构建者后有产品，产品由构建者创建

   总体来说，建造者模式适用于需要创建具有复杂结构或多个配置选项的对象，而且希望将构建过程与表示分离的情况。

   建造者模式UML结构图如下：

        

   一、能解决什么问题？

   当一个对象的构造包含多个参数，尤其是这些参数有多种组合或依赖关系时，直接使用构造函数来创建对象会使代码变得难以维护和阅读。

   参数过多的构造函数会导致“构造函数爆炸”，即需要定义多个构造函数来处理不同的参数组合。

   二、涉及的角色

   1. Product(目标类)

   最终要生成的对象，代码示例如下：

public class Product {
    ArrayList<String> parts = new ArrayList<>();

    public void add(String part) {
        parts.add(part);
    }

    public void show() {
        System.out.println(parts);
    }
}

   2. Builder(建造者的抽象基类)

   承载了复杂对象的构建过程，代码示例如下： 

public abstract class Builder {

    /**
     * 构建部分A
     */
    public abstract void buildPartA();

    /**
     * 构建部分B
     */
    public abstract void buildPartB();

    /**
     * 获取展示结果
     *
     * @return 执行结果
     */
    public abstract Product getResult();
} 

   3. ConcreteBuilder(具体的建造者)

   依赖Product类，ConcreteBuilder跟Product属于组合关系，ConcreteBuilder属于整体类，Product属于部分类

   代码示例如下： 

public class ConcreteBuilder extends Builder {

    private final Product product = new Product();

    @Override
    public void buildPartA() {
        product.add("构建产品的上半部分");
    }

    @Override
    public void buildPartB() {
        product.add("构建产品的下半部分");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

   4. Director

   决定如何构建最终产品的算法。控制Builder的生产过程，Director跟Builder属于组合关系，Director属于整体类，Builder属于部分类。

   其会包含一个负责组装的方法void Construct(Builder builder)， 在这个方法中通过调用builder的方法，就可以设置builder，等设置完成后，就可以通过builder的 getProduct() 方法获得最终的产品

   代码示例如下：

public class Director {
    private final Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
    }
}

   客户端调用：

public class Client {
    public static void main(String[] args) {

        ConcreteBuilder concreteBuilder = new ConcreteBuilder();

        //控制Builder的生产过程
        Director director = new Director(concreteBuilder);
        director.construct();

        Product product = concreteBuilder.getResult();
        product.show();
    }
}


//运行结果
[构建产品的上半部分, 构建产品的下半部分]

  再来一个简化建造者模式的使用案例：

  Computer类：

public class Computer {

    /**
     * 必须字段
     */
    private final String cpu;

    /**
     * 必须字段
     */
    private final String ram;

    /**
     * 可选字段
     */
    private final int usbCount;

    /**
     * 可选字段
     */
    private final String keyboard;

    /**
     * 可选字段
     */
    private final String display;

    public Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.ram = builder.ram;
        this.usbCount = builder.usbCount;
        this.keyboard = builder.keyboard;
        this.display = builder.display;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", usbCount=" + usbCount +
                ", keyboard='" + keyboard + '\'' +
                ", display='" + display + '\'' +
                '}';
    }

    public static class Builder {
        /**
         * 必须字段
         */
        private final String cpu;

        /**
         * 必须字段
         */
        private final String ram;

        /**
         * 可选字段
         */
        private int usbCount;

        /**
         * 可选字段
         */
        private String keyboard;

        /**
         * 可选字段
         */
        private String display;

        public Builder(String cpu, String ram) {
            this.cpu = cpu;
            this.ram = ram;
        }

        public Builder setUsbCount(int usbCount) {
            this.usbCount = usbCount;
            return this;
        }

        public Builder setKeyboard(String keyboard) {
            this.keyboard = keyboard;
            return this;
        }

        public Builder setDisplay(String display) {
            this.display = display;
            return this;
        }

        public Computer build() {
            return new Computer(this);
        }
    }
}

  客户端类Client：

public class Client {
    public static void main(String[] args) {
        Computer computer = new Computer.Builder("因特尔", "三星")
                .setUsbCount(2)
                .setKeyboard("罗技")
                .setDisplay("LG28寸")
                .build();
        System.out.println(computer.toString());
    }
}

//运行结果
Computer{cpu='因特尔', ram='三星', usbCount=2, keyboard='罗技', display='LG28寸'}

  四、使用场景

  在Java源码里，建造者模式最典型的体现就是StringBuilder

  StringBuilder是Java中的一个用于构建字符串的类，它允许在不创建新的对象的情况下，对字符串进行可变操作。它通过提供一系列方法来逐步构建字符串，并通过链式调用使代码简洁易读。

  代码示例如下：

public class StringBuilderExample {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder();
        
        builder.append("Hello, ")
               .append("world")
               .append("!")
               .insert(7, "Java ")
               .replace(13, 18, "World")
               .deleteCharAt(6);
        
        String result = builder.toString();
        System.out.println(result); // 输出: "Hello Java World!"
    }
}

  注意：lombok中的@Builder 注解通过注入一个静态内部类作为建造者，简化了建造者模式的使用，减少了样板代码。这种方式在代码中使用起来更加简洁，并且提高了可读性。

  举个例子：

  给User类加上@Data和@Builder注解

@Data
@Builder
public class User {
    private String name;
    private int age;
} 

  通过IDEA的Delombok功能，右键点击并选择 Refactor -> Delombok, 选择 @Builder 查看代码：

@Data
public class User {
    private String name;
    private int age;

    User(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    public static class UserBuilder {
        private String name;
        private int age;

        UserBuilder() {
        }

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

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

        public User build() {
            return new User(name, age);
        }

        public String toString() {
            return "User.UserBuilder(name=" + this.name + ", age=" + this.age + ")";
        }
    }
}

  客户端类： 

public class Client {
    public static void main(String[] args) {
        User user = User.builder()
                .name("tom")
                .age(18)
                .build();
        System.out.println(user);
    }
}

// 运行结果
User(name=tom, age=18)

  五、建造者模式与简单工厂模式的区别

  两者的区别在于，建造者模式多出一个Builder类，使得创建对象的灵活性大大增加，适用于如下场景：

  1. 创建一个对象，多个同样的方法的调用顺序不同，产生的结果不同

  2. 创建一个对象，特别复杂，参数多，而且很多参数都有默认值