Java设计模式之创建型-建造者模式（UML类图+案例分析）

目录

一、基本概念

二、UML类图

三、角色设计 

四、案例分析

五、总结

---

一、基本概念

建造者模式是一种创建型设计模式，它使我们将一个复杂对象的构建步骤分离出来，使得同样的构建过程可以创建不同的表示。该模式的目的是将构建复杂对象的过程抽象化，从而减少代码的重复和复杂度。

在建造者模式中，我们通过Builder接口或抽象类定义了一个标准的构建流程，然后让不同的具体构造者按照这个标准来实现自己的构建流程。同时，我们还定义了一个指导者（Director）类，用于按照特定的顺序执行构建流程，从而完成对象的构建。

二、UML类图

三、角色设计 

角色	描述
产品	被建造的复杂对象
抽象建造者	定义了一个创建产品各个子部件的抽象接口
具体建造者	实现Builder接口，构建并组装各个部件
指导者	调用建造者接口完成复杂对象的创建，隔离了客户与对象的生产过程

四、案例分析

例如有如下一个场景：日常生活中手机也分为有基础入门、中端和高端旗舰机三个档次的手机，客户这时候提出了一个需求：我想购买一部基础入门机和一部高端旗舰机！客户是完全不需要知晓整部手机的生产过程，只需要传达给指挥者，指挥者通过对应的手机建造者去控制生产对应的手机即可，下面我们通过代码实现这个案例：

手机类：

包含了基础的核心处理器、内存和电池3个参数。

public class Phone {

    private String cpu;

    private String memory;

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getMemory() {
        return memory;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public String getBattery() {
        return battery;
    }

    public void setBattery(String battery) {
        this.battery = battery;
    }

    private String battery;
}

建造者抽象类：

提供了一个基础的手机对象，建造核心处理器，内存和电池三个抽象方法，返回建造完毕的手机对象。

public abstract class Builder {

    protected Phone phone = new Phone();

    public abstract void buildCpu();

    public abstract void buildMemory();

    public abstract void buildBattery();

    public Phone builder(){
        return this.phone;
    }
}

一个基础手机实现抽象建造者类：

public class BasicPhoneBuilder extends Builder{


    @Override
    public void buildCpu() {
        System.out.println("麒麟980");
        phone.setCpu("麒麟980");
    }

    @Override
    public void buildMemory() {
        System.out.println("8G内存");
        phone.setMemory("8G内存");
    }

    @Override
    public void buildBattery() {
        System.out.println("22.5W快充");
        phone.setBattery("22.5W快充");
    }
}

一个高端手机实现建造者抽象类：

public class AdvancedPhoneBuilder extends Builder{


    @Override
    public void buildCpu() {
        System.out.println("麒麟9000");
        phone.setCpu("麒麟9000");
    }

    @Override
    public void buildMemory() {
        System.out.println("12G内存");
        phone.setMemory("12G内存");
    }

    @Override
    public void buildBattery() {
        System.out.println("66W快充");
        phone.setBattery("66W快充");
    }
}

创建一个指挥者，用于建造出不同类型手机：

public class Director {

    private Builder builder;

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

    public Phone builder(){
        builder.buildCpu();
        builder.buildMemory();
        builder.buildBattery();
        return builder.builder();
    }
}

客户端：

public class Client {

    public static void main(String[] args) {
        Builder basicPhoneBuilder = new BasicPhoneBuilder();
        Phone basicPhone = new Director(basicPhoneBuilder).builder();

        Builder advancedPhoneBuilder = new AdvancedPhoneBuilder();
        Phone advancedPhone = new Director(advancedPhoneBuilder).builder();
    }
}

运行结果如下：

五、总结

优点：

1、将构建复杂对象的过程封装起来，简化了代码结构和逻辑，客户端不需要知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的过程可以创建出不同的产品对象。

2、每一个建造者都相对独立，和其他建造者没有关系，因此可以很方便的替换具体的建造者或者添加新的具体建造者，客户端使用不同的建造者可以获得不同的产品对象，系统扩展方便，符合“开闭原则”。

缺点：

1、添加新的部件需要修改抽象类和具体构造者的代码。

2、建造者模式所创建的产品都有很多的共同之处，组成部分相似，如果产品之间的差异性很大，则组成部分不同，不适合使用建造者模式，因此范围很局限。

应用场景：

1、相同的方法，不同的执行顺序，产生不同的事件结果时。

2、多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。

3、产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能。

4、初始化一个对象消耗的资源非常大，则可以通过建造者模式分步初始化。

符合的设计原则：

1、单一职责原则（Single Responsibility Principle）

建造者仅负责构建产品，产品仅负责描述自身，职责单一。

2、开闭原则（Open Closed Principle）

可以新增建造者而不影响已有代码，符合开闭原则。

3、里氏替换原则（Liskov Substitution Principle）

扩展新的建造者仍遵循相同接口，不影响客户端使用。

4、依赖倒转原则（Dependency Inversion Principle）

建造者和指挥者依赖抽象接口，不依赖具体实现类。

5、接口隔离原则（Interface Segregation Principle）

产品接口和建造者接口职责单一，不会强迫实现不需要的方法。

建造者模式将复杂对象的构建与表示分离，使得相同的构建过程可以创建不同表示。它是一步一步创建一个复杂对象的最佳模式。