【Java设计模式004】建造者模式

概述

首先来看一个例子，假设我们需要建造一个房子，那么必须建造墙、屋顶、地板、门…如果还需要游泳池、健身室，那么该怎么办呢？最简单的方式是创建一个 House 基类，将公有部分抽象出来，然后根据需求组合的不同构建不同的子类，例如带游泳池的房子、不带游泳池带健身房的房子…这显然会造成类爆炸。

为了解决这个问题，我们也可以创建一个包含所有可能参数的房屋基类，提供一个超级构造器并用它控制房屋对象的构造，这样做的问题在于通常情况下，绝大部分的参数都没有使用，这使得对于构造函数的调用十分不简洁。

构造器模式使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。它将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示，该模式针对的主要问题在于：

由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定；
构造对象的参数过多，使用折叠构造函数模式和 Javabean 模式容易造成调用者混乱；

第一个问题很好理解，我这里主要介绍一下第二个问题，比方说我们有一个类：

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;
	...
}

第一种传递参数的方式是折叠构造函数模式 (telescoping constructor pattern)

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;
    private final int carbohydrate;

    public NutritionFacts(int servingSize, int servings) {
        this(servingSize, servings, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories) {
        this(servingSize, servings, calories, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories, int fat) {
        this(servingSize, servings, calories, fat, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium) {
        this(servingSize, servings, calories, fat, sodium, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium, int carbohydrate) {
        this.servingSize = servingSize;
        this.servings = servings;
        this.calories = calories;
        this.fat = fat;
        this.sodium = sodium;
        this.carbohydrate = carbohydrate;
    }
}

它的主要问题在于代码编写难度大，用户很有可能调用错误的参数。第二种设置参数的方式是 JavaBeans 模式：

public class NutritionFacts {
    private int servingSize = -1;
    private int servings = -1;
    private int calories = -1;
    private int fat = -1;
    private int sodium = -1;
    private int carbohydrate = -1;

    public NutritionFacts() {
        
    }

    public void setServingSize(int servingSize) {
        this.servingSize = servingSize;
    }

    public void setServings(int servings) {
        this.servings = servings;
    }

    public void setCalories(int calories) {
        this.calories = calories;
    }

    public void setFat(int fat) {
        this.fat = fat;
    }

    public void setSodium(int sodium) {
        this.sodium = sodium;
    }

    public void setCarbohydrate(int carbohydrate) {
        this.carbohydrate = carbohydrate;
    }
}

这种方式的问题在于将对象的构建过程拆分到多个调用中，这很容易导致构造过程中对象的不一致，程序员需要付出额外的努力保证线程安全；
为了解决这些问题，建造者模式横空出世，它的主要角色如下：

抽象建造者类（Builder）：这个接口规定要实现复杂对象部分的创建，并不涉及具体的部件对象的创建。
具体建造者类（ConcreteBuilder）：实现/继承 Builder ，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。
产品类（Product）：要创建的复杂对象。
指挥者类（Director）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

该模式的主要优点：

封装性好，将产品和制造者解耦；
可以精确地控制产品的创建过程；
使用相同的创建过程可以创建不同的产品对象；
建造者扩展十分容易，复合开闭原则；

实现

建造者模式的实现思路如下：

明确产品类的组成零件；
在抽象建造者类中声明各个零件的建造方法；
为每个具体产品创建具体建造者类，并实现其构造步骤。
考虑创建指挥者类。它可以使用同一建造者对象来封装多种构造产品的方式；
客户端通过指挥者类获取产品对象。

以自行车为例，一辆自行车包括车架、座椅和轮子，自行车类如下：

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

    public Bike() {
    }

    public Bike(String seat, String frame, String wheel) {
        this.seat = seat;
        this.frame = frame;
        this.wheel = wheel;
    }

    public String getSeat() {
        return seat;
    }

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

    public String getFrame() {
        return frame;
    }

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

    public String getWheel() {
        return wheel;
    }

    public void setWheel(String wheel) {
        this.wheel = wheel;
    }

    @Override
    public String toString() {
        return "Bike{" +
                "seat='" + seat + '\'' +
                ", frame='" + frame + '\'' +
                ", wheel='" + wheel + '\'' +
                '}';
    }
}

现在假定 BikeA 的建造顺序是车架→轮子→座椅；BikeB 的建造顺序是车架→座椅→轮子；那么抽象建造者的定义如下：

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

    public abstract void buildSeat();

    public abstract void buildWheel();

    public abstract void buildFrame();

    public abstract Bike build();
}

具体建造者 A 的代码如下：

public class BikeABuilder extends BikeBuilder{
    @Override
    public void buildSeat() {
        bike.setSeat("BikeA座椅");
        System.out.println("A其他座椅安装操作");
    }

    @Override
    public void buildWheel() {
        bike.setWheel("BikeA轮子");
        System.out.println("A其他轮子安装操作");
    }

    @Override
    public void buildFrame() {
        bike.setFrame("BikeA车架");
        System.out.println("A其他车架安装操作");
    }

    @Override
    public Bike build() {
        System.out.println("A其他构造操作");
        return bike;
    }
}

具体建造者 B 的代码如下：

public class BikeBBuilder extends BikeBuilder{
    @Override
    public void buildSeat() {
        bike.setSeat("BikeB座椅");
        System.out.println("B其他座椅安装操作");
    }

    @Override
    public void buildWheel() {
        bike.setWheel("BikeB轮子");
        System.out.println("B其他轮子安装操作");
    }

    @Override
    public void buildFrame() {
        bike.setFrame("BikeB车架");
        System.out.println("B其他车架安装操作");
    }

    @Override
    public Bike build() {
        System.out.println("B其他构造操作");
        return bike;
    }
}

指挥者类如下：

public class Director {
    public Bike construct(String bikeType) {
        if (bikeType == null || bikeType.isEmpty()) {
            throw new IllegalArgumentException();
        }
        BikeBuilder builder;
        if ("a".equals(bikeType)) {
            builder = new BikeABuilder();
            System.out.println("============= 开始构筑A =============");
            builder.buildFrame();
            builder.buildWheel();
            builder.buildSeat();
        } else if ("b".equals(bikeType)) {
            builder = new BikeBBuilder();
            System.out.println("============= 开始构筑B =============");
            builder.buildFrame();
            builder.buildSeat();
            builder.buildWheel();
        } else {
            throw new RuntimeException();
        }

        return builder.build();
    }
}

测试类代码如下：

public class Client {
    public static void main(String[] args) {
        Director director = new Director();
        Bike bike = director.construct("a");
        System.out.println("=======================================");
        System.out.println(bike);
        bike = director.construct("b");
        System.out.println("=======================================");
        System.out.println(bike);
    }
}

测试结果如下：

============= 开始构筑A =============
A其他车架安装操作
A其他轮子安装操作
A其他座椅安装操作
A其他构造操作
=======================================
Bike{seat='BikeA座椅', frame='BikeA车架', wheel='BikeA轮子'}
============= 开始构筑B =============
B其他车架安装操作
B其他座椅安装操作
B其他轮子安装操作
B其他构造操作
=======================================
Bike{seat='BikeB座椅', frame='BikeB车架', wheel='BikeB轮子'}

严格来说，程序中并不一定需要指挥者类。客户端代码可直接以特定顺序调用创建步骤，也可以将指挥者类和建造者类进行合并。不过，指挥者类中非常适合放入各种例行构造流程，以便在程序中反复使用。此外，对于客户端代码来说，指挥者类完全隐藏了产品构造细节。客户端只需使用指挥者类来构造产品。

除此之外还可以将建造者类作为产品类的一个静态内部类，并在产品类中添加一个接收建造者类的构造器，以 Option 为例：

class Option{
	private Option(Builder builder) {
        this.numberOfArgs = -1;
        this.type = String.class;
        this.values = new ArrayList();
        this.argName = builder.argName;
        this.description = builder.description;
        this.longOpt = builder.longOpt;
        this.numberOfArgs = builder.numberOfArgs;
        this.opt = builder.opt;
        this.optionalArg = builder.optionalArg;
        this.required = builder.required;
        this.type = builder.type;
        this.valuesep = builder.valuesep;
    }
    
	public static final class Builder {
        private final String opt;
        private String description;
        private String longOpt;
        private String argName;
        private boolean required;
        private boolean optionalArg;
        private int numberOfArgs;
        private Class<?> type;
        private char valuesep;

        private Builder(String opt) throws IllegalArgumentException {
            this.numberOfArgs = -1;
            this.type = String.class;
            OptionValidator.validateOption(opt);
            this.opt = opt;
        }

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

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

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

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

        public Builder optionalArg(boolean isOptional) {
            this.optionalArg = isOptional;
            return this;
        }

        public Builder required() {
            return this.required(true);
        }

        public Builder required(boolean required) {
            this.required = required;
            return this;
        }

        public Builder type(Class<?> type) {
            this.type = type;
            return this;
        }

        public Builder valueSeparator() {
            return this.valueSeparator('=');
        }

        public Builder valueSeparator(char sep) {
            this.valuesep = sep;
            return this;
        }

        public Builder hasArg() {
            return this.hasArg(true);
        }

        public Builder hasArg(boolean hasArg) {
            this.numberOfArgs = hasArg ? 1 : -1;
            return this;
        }

        public Builder hasArgs() {
            this.numberOfArgs = -2;
            return this;
        }

        public Option build() {
            if (this.opt == null && this.longOpt == null) {
                throw new IllegalArgumentException("Either opt or longOpt must be specified");
            } else {
                return new Option(this);
            }
        }
    }
}

这样通过链式调用就可以成功创建出产品对象，解决了传递参数过多的问题。

Option classOption = Option.builder("c")
                .hasArg()
                .valueSeparator(' ')
                .argName("classpath hishishis")
                .required()
                .desc("class Path")
                .build();

总结

建造者模式的应用很广，当你希望使用代码创建不同形式的产品（例如石头或木头房屋）时，可使用建造者模式。此外，使用建造者模式可避免 “重叠构造函数（telescoping constructor）” 的出现。但是建造者模式的缺点也很明显：

建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制；
如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

很多人会将建造者模式和与工厂模式相比，虽然二者的目的都是构造出一个产品对象，但是二者的着重点不同，工厂方法模式注重的是整体对象的创建方式；而建造者模式注重的是部件构建的过程，意在通过一步一步地精确构造创建出一个复杂的对象。

往期回顾

文中难免会出现一些描述不当之处（尽管我已反复检查多次），欢迎在留言区指正，相关的知识点也可进行分享，希望大家都能有所收获！！如果觉得我的文章写得还行，不妨支持一下。你的每一个转发、关注、点赞、评论都是对我最大的支持！