本文共 4526 字，大约阅读时间需要 15 分钟。

设计模式：创建型模式 - 建造者模式

概述

建造者模式（Builder Pattern）是一种创建型设计模式，旨在将一个复杂对象的构建过程与其表示分离。通过这种方式，可以使用相同的构建过程创建不同的表示，使得系统更加灵活和可扩展。

特点

• 分离构建与表示：建造者模式将对象的构建过程与最终的表示方式分开，使得相同的构建过程能够生成不同的表示形式。
• 解耦构建和装配：通过引入建造者和指挥者，构建过程和装配过程可以解耦，从而支持不同的构建顺序和装配方式。
• 复用构建过程：相同的构建过程可以用于创建不同的对象，减少代码重复，提高复用率。

结构

建造者模式包含以下主要角色：

实例

自行车生产示例

在自行车生产中，建造者模式可以帮助将车架、车座等部件的生产过程与最终的车辆组装分开。以下是使用建造者模式的具体实现：

类图

├── Bike
├── Builder
│   ├── MobikeBuilder
│   └── OfoBuilder
└── Director

代码示例

// 产品类
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 mBike = new Bike();
    public abstract void buildFrame();
    public abstract void buildSeat();
    public abstract Bike createBike();
}
// 具体建造者
public class MobikeBuilder extends Builder {
    @Override
    public void buildFrame() { mBike.setFrame("铝合金车架"); }
    @Override
    public void buildSeat() { mBike.setSeat("真皮车座"); }
    @Override
    public Bike createBike() { return mBike; }
}
public class OfoBuilder extends Builder {
    @Override
    public void buildFrame() { mBike.setFrame("碳纤维车架"); }
    @Override
    public void buildSeat() { mBike.setSeat("橡胶车座"); }
    @Override
    public Bike createBike() { return mBike; }
}
// 指挥者
public class Director {
    private Builder mBuilder;
    public Director(Builder builder) { mBuilder = builder; }
    public Bike construct() {
        mBuilder.buildFrame();
        mBuilder.buildSeat();
        return mBuilder.createBike();
    }
}
// 测试类
public class Client {
    public static void main(String[] args) {
        showBike(new OfoBuilder());
        showBike(new MobikeBuilder());
    }
    private static void showBike(Builder builder) {
        Director director = new Director(builder);
        Bike bike = director.construct();
        System.out.println(bike.getFrame());
        System.out.println(bike.getSeat());
    }
}

输出结果：

碳纤维车架橡胶车座
铝合金车架真皮车座

优缺点

优点

• 封装性高：将构建过程和最终的表示分开，提高了系统的稳定性。
• 易于扩展：通过引入新的建造者类，可以轻松扩展系统功能，符合开闭原则。
• 代码可读性高：通过一步步构建的方式，代码逻辑更加清晰，便于维护和理解。

缺点

• 适用范围有限：建造者模式适用于对象构建过程复杂且各部分相似的场景。如果产品之间的差异性较大，可能不适合使用。
• 增加了间接对象：引入了建造者和指挥者类，可能会增加系统的复杂性。

使用场景

• 构建复杂对象：当一个对象由多个部分组成，且每个部分的构建过程复杂时，建造者模式非常有用。
• 构建过程独立于表示：当构建过程和最终的表示方式需要解耦时，建造者模式能够提供有效的解决方案。

模式扩展

参数多的类构造优化

在某些情况下，类的构造器需要传入大量参数，这会导致代码难以阅读和维护。通过引入建造者模式，可以将参数的设置过程封装起来，提高代码的可读性。

重构前的代码

public class Phone {
    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;
    public Phone(String cpu, String screen, String memory, String mainboard) {
        this.cpu = cpu;
        this.screen = screen;
        this.memory = memory;
        this.mainboard = mainboard;
    }
    // getter 和 setter 方法...
}

重构后的代码

public class Phone {
    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;
    private Phone(Builder builder) {
        cpu = builder.cpu;
        screen = builder.screen;
        memory = builder.memory;
        mainboard = builder.mainboard;
    }
    // 内部建造者类
    public static final class Builder {
        private String cpu;
        private String screen;
        private String memory;
        private String mainboard;
        public Builder() {}
        public Builder cpu(String val) { this.cpu = val; return this; }
        public Builder screen(String val) { this.screen = val; return this; }
        public Builder memory(String val) { this.memory = val; return this; }
        public Builder mainboard(String val) { this.mainboard = val; return this; }
        public Phone build() { return new Phone(this); }
    }
    // 其他方法...
}

测试类

public class Client {
    public static void main(String[] args) {
        Phone phone = new Phone.Builder()
                .cpu("intel")
                .mainboard("华硕")
                .memory("金士顿")
                .screen("三星")
                .build();
        System.out.println(phone);
    }
}

对比工厂方法模式

**工厂方法模式（Factory Method）**与建造者模式的主要区别在于：

• 工厂方法模式关注的是整体对象的创建方式，而建造者模式关注的是对象的构建过程。
• 工厂方法模式通常用于多种产品线的创建，而建造者模式则适用于构造复杂对象的不同组件。

抽象工厂模式（Abstract Factory）

抽象工厂模式与建造者模式的主要区别在于：

• 抽象工厂模式关注的是产品家族的创建，即一系列相关的产品组合。
• 建造者模式关注的是单个复杂产品的构建过程。

两者的主要区别在于，抽象工厂模式更关注的是产品的生产工厂，而建造者模式则关注的是产品的组装过程。

转载地址：http://qkhfk.baihongyu.com/