JAVA设计模式第九章:建造者模式

一. 什么是建造者模式

通过将对象的构建过程从表现层隔离出来，使得相同的构建过程可以用来创建不同的表现形式

二. 建造者模式解决了什么问题

用于简化和优化复杂对象的创建过程,提高创建效率和代码可读性;

三. 核心概念

3.1 四个角色

1. Product(产品角色): 要创建的产品对象
2. Builder(抽象建造者): 创建产品以及部件的接口定义
3. ConcreateBuilder(具体建造者): 抽象建造者的具体实现
4. Director(指挥者): 使用Builder接口的对象;

3.2 类图

以手机制造为例

制造苹果手机和小米手机

四. 代码演示

/**
 * 手机 产品
 *
 * @author cans
 * @date 2024/2/18
 **/
public class PhoneProduct {

    private String cpu;

    private String arm;

    private String disk;

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

    public void setArm(String arm) {
        this.arm = arm;
    }

    public void setDisk(String disk) {
        this.disk = disk;
    }

    @Override
    public String toString() {
        return "PhoneProduct{" +
                "cpu='" + cpu + '\'' +
                ", arm='" + arm + '\'' +
                ", disk='" + disk + '\'' +
                '}';
    }
}

/**
 * 手机抽象建造者
 */
public interface PhoneBuilder {

    void buildCpu();

    void BuildArm();

    void buildDisk();

    PhoneProduct build();
}

/**
 * 苹果手机建造者实现
 *
 * @author cans
 * @date 2024/2/18
 **/
public class IPhoneBuilderImpl implements PhoneBuilder {

    private final PhoneProduct product;

    public IPhoneBuilderImpl() {
        product = new PhoneProduct();
    }

    @Override
    public void buildCpu() {
        product.setCpu("A15");
    }

    @Override
    public void BuildArm() {
        product.setArm("4G");
    }

    @Override
    public void buildDisk() {
        product.setDisk("512G");
    }

    @Override
    public PhoneProduct build() {
        return product;
    }
}

/**
 * 小米手机建造者实现
 *
 * @author cans
 * @date 2024/2/18
 **/
public class MiPhoneBuilderImpl implements PhoneBuilder {

    private final PhoneProduct product;

    public MiPhoneBuilderImpl() {
        product = new PhoneProduct();
    }

    @Override
    public void buildCpu() {
        product.setCpu("澎湃S1");
    }

    @Override
    public void BuildArm() {
        product.setArm("12G");
    }

    @Override
    public void buildDisk() {
        product.setDisk("1024G");
    }

    @Override
    public PhoneProduct build() {
        return product;
    }
}

/**
 * 手机创建 - 指挥者
 * @author cans
 * @date 2024/2/18
 **/
public class PhoneDirector {

    private PhoneBuilder builder;

    public PhoneDirector(PhoneBuilder phoneBuilder){
        this.builder = phoneBuilder;
    }

    public void build() {
        builder.buildCpu();
        builder.BuildArm();
        builder.buildDisk();
    }
}

测试代码1: 生产苹果手机

    @Test
    public void buildIPhone(){
        PhoneBuilder builder = new IPhoneBuilderImpl();
        PhoneDirector director = new PhoneDirector(builder);
        director.build();
        PhoneProduct product = builder.build();
        System.out.println(product);
    }

测试1输出:

PhoneProduct{cpu='A15', arm='4G', disk='512G'}

Process finished with exit code 0

测试代码2: 生产小米手机

只需要更换对应的建造者实现即可

    @Test
    public void buildMiPhone(){
        PhoneBuilder builder = new MiPhoneBuilderImpl();
        PhoneDirector director = new PhoneDirector(builder);
        director.build();
        PhoneProduct product = builder.build();
        System.out.println(product);
    }

测试2输出:

PhoneProduct{cpu='澎湃S1', arm='12G', disk='1024G'}

Process finished with exit code 0

五. 总结

优势

1. 建造过程和使用分离(解耦): 使用的时候无需关心建造过程,使用相同的创建过程即可创建不同的复杂对象
2. 每一个建造者都相对独立(符合开闭原则): 可以很方便地替换具体建造者或增加新的具体建造者，扩展方便
3. 对象创建更加精细化(可维护性增强): 复杂问题拆分简单化,大大增强了代码的后期可维护性;

劣势

1. 产品之前差异性太大的不适用建造者模式
2. 如果产品属性相互依赖,需要维护建造顺序