Java设计模式之建造者模式

目录

概述

结构

案例

优点

缺点

使用场景

模式扩展

---

概述

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

分离了部件的构造(由Builder来负责)和装配(由Director负责)。 从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况。

由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。

建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。

结构

抽象建造者类：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的部件对象的创建。

具体建造者类：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。

产品类：要创建的复杂对象。

指挥者类：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

案例

创建产品类

public class Bike {
    private String frame;
    private String seat;

    public String getFrame() {
        return frame;
    }

    public void setFrame(String frame) {
        this.frame = frame;
    }

    public String getSeat() {
        return seat;
    }

    public void setSeat(String seat) {
        this.seat = seat;
    }
}

抽象建造者类 

public abstract class Builder {
    protected Bike bike = new Bike();

    public abstract void createFrame();

    public abstract void createSeat();

}

创建具体建造者类 

//A类型的车辆建造者
public class ABuilder extends Builder {
    @Override
    public void createFrame() {
        bike.setFrame("安装A型车架");
    }

    @Override
    public void createSeat() {
        bike.setSeat("安装A型车座");
    }
}



//B类型的车辆建造者
public class BBuilder extends Builder {
    @Override
    public void createFrame() {
        bike.setFrame("安装B型车架");
    }

    @Override
    public void createSeat() {
        bike.setSeat("安装B型车座");
    }
}

指挥者

public class Director {

    public Builder builder;

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

    //组装
    public Bike construct(){
        builder.createFrame();
        builder.createSeat();
        return builder.bike;
    }
}

测试 

public class Client {
    public static void main(String[] args) {
        //创建指挥者对象，给定具体建造者参数
        Director director = new Director(new ABuilder());
        //组装车辆
        Bike bike = director.construct();
        System.out.println(bike.getFrame());
        System.out.println(bike.getSeat());
    }
}

以上代码运行结果为：

安装A型车架

安装A型车座

对于客户端来说，并不需要知道如何具体创建出一个自行车对象，只需要调用方法就可以返回一个自行车对象。

优化

也可以将抽线建造者类与指挥类结合来化简系统复杂度。

public abstract class Builder {
    protected Bike bike = new Bike();

    public abstract void createFrame();

    public abstract void createSeat();

    public abstract Bike createBike();

    //将指挥者类中的组装代码放在这里
    public Bike construct(){
        this.createFrame();
        this.createSeat();
        Bike bike = this.createBike();
        return bike;
    }
}

public class Client {
    public static void main(String[] args) {
        Builder builder = new ABuilder();
        Bike bike = builder.construct();
        System.out.println(bike.getFrame());
        System.out.println(bike.getSeat());
    }
}

以上代码运行结果为：

安装A型车架

安装A型车座

但是缺点应该是暴露了创建对象过程中的具体创建方法，如果指挥者中的代码复杂的话，还是要创建出Director类

优点

• 建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。
• 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
• 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
• 建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。符合开闭原则。

缺点

造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。

使用场景

建造者模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用。

• 创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。
• 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。

模式扩展

当类构造器需要很多参数时，创建类实例时，代码可读性较差，且容易发生错误，可以使用建造者模式对类进行重构

public class Phone {
    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;

    //将有参构造器私有化，禁止外部调用
    private Phone(Builder builder) {
        this.cpu = builder.cpu;
        this.screen = builder.screen;
        this.memory = builder.memory;
        this.mainboard = builder.mainboard;
    }

    //定义内部类Builder
    public static final class Builder {
        private String cpu;
        private String screen;
        private String memory;
        private String mainboard;

        //外部可以调用Builder的无参构造进行初始化
        public Builder() {
        }

        //对属性进行赋值
        public Builder cpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

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

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

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

        //调用Phone有参构造器创建Phone对象
        public Phone builder(){
            return new Phone(this);
        }
    }
}

public class client {
    public static void main(String[] args) {
        Phone phone = new Phone.Builder()
                .cpu("cpu")
                .screen("屏幕")
                .memory("内存条")
                .mainboard("主板")
                .builder();
        System.out.println(phone);
    }
}

运行结果为：

demo03.Phone@1540e19d

这种创建对象的方式可读性更好，并且使用更加方便。