高效Java编程-02. 当构造方法参数过多时使用builder模式

  静态工厂和构造方法都有一个限制:它们不能很好地扩展到很多可选参数的情景。请考虑一个代表包装食品上的营养成分标签的例子。这些标签有几个必需的属性——每次建议的摄入量,每罐的份量和每份卡路里 ,以及超过 20 个可选的属性——总脂肪、饱和脂肪、反式脂肪、胆固醇、钠等等。大多数产品只有这些可选字段中的少数,且具有非零值。

  应该为这样的类编写什么样的构造方法或静态工厂?传统上,程序员使用了可伸缩(telescoping constructor)构造方法模式,在这种模式中,首先提供一个只有必需参数的构造方法,接着提供增加了一个可选参数的构造函数,然后提供增加了两个可选参数的构造函数,等等,最终在构造函数中包含所有必需和可选参数。以下就是它在实践中的样子。为了简便起见,只显示了四个可选属性:

   // Telescoping constructor pattern - does not scale well!
   public class NutritionFacts {
    private final int servingSize; // (mL) required
    private final int servings; // (per container) required
    private final int calories; // (per serving) optional
    private final int fat; // (g/serving) optional
    private final int sodium; // (mg/serving) optional
    private final int carbohydrate; // (g/serving) optional

    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;
    }
   }

  当想要创建一个实例时,可以使用包含所有要设置的参数的最短参数列表的构造方法:

   NutritionFacts cocaCola = new NutritionFacts(240, 8, 100, 0, 35, 27);

  通常情况下,这个构造方法的调用需要许多你不想设置的参数,但是你不得不为它们传递一个值。 在这种情况下,我们为 fat 属性传递了 0 值。「只有」六个参数可能看起来并不那么糟糕,但随着参数数量的增加,它很快就会失控。

  简而言之,可伸缩构造方法模式是有效的,但是当有很多参数时,很难编写客户端代码,而且很难读懂它。 读者不知道这些值是什么意思,并且必须仔细地去数参数才能找到答案。一长串相同类型的参数可能会导致一些细微的 bug。如果客户端不小心写反了两个这样的参数,编译器并不会报错,但是程序在运行时会出现错误行为 (详见第 51 条)。

  当在构造方法中遇到许多可选参数时,另一种选择是 JavaBeans 模式,在这种模式中,调用一个无参的构造方法来创建对象,然后调用 setter 方法来设置每个必需的参数和可选参数:

   // JavaBeans Pattern - allows inconsistency, mandates mutability
   public class NutritionFacts {
    // Parameters initialized to default values (if any)
    private int servingSize = -1; // Required; no default value
    private int servings = -1; // Required; no default value
    private int calories = 0;
    private int fat = 0;
    private int sodium = 0;
    private int carbohydrate = 0;

    public NutritionFacts() 

    // Setters
    public void setServingSize(int val) 
    public void setServings(int val) 
    public void setCalories(int val) 
    public void setFat(int val) 
    public void setSodium(int val) 
    public void setCarbohydrate(int val) 
   }

  这种模式没有伸缩构造方法模式的缺点。有点冗长,但创建实例很容易,并且易于阅读所生成的代码:

   NutritionFacts cocaCola = new NutritionFacts();
   cocaCola.setServingSize(240);
   cocaCola.setServings(8);
   cocaCola.setCalories(100);
   cocaCola.setSodium(35);
   cocaCola.setCarbohydrate(27);

  不幸的是,JavaBeans 模式本身有严重的缺陷。由于构造方法被分割成了多次调用,所以在构造过程中 JavaBean 可能处于不一致的状态。该类没有通过检查构造参数参数的有效性来强制一致性的选项。在不一致的状态下尝试使用对象可能会导致一些错误,这些错误与平常代码的BUG很是不同,因此很难调试。一个相关的缺点是,JavaBeans 模式排除了让类不可变的可能性(详见第 17 条),并且需要程序员增加工作以确保线程安全。

  通过在对象构建完成时手动「冻结」对象,并且不允许它在解冻之前使用,可以减少这些缺点,但是这种变体在实践中很难使用并且很少使用。 而且,在运行时会导致错误,因为编译器无法确保程序员会在使用对象之前调用 freeze 方法。

  幸运的是,还有第三种选择,它结合了可伸缩构造方法模式的安全性和 JavaBean 模式的可读性。 它是 Builder 模式[Gamma95] 的一种形式。客户端不直接构造所需的对象,而是调用一个包含所有必需参数的构造方法 (或静态工厂)得到获得一个 builder 对象。然后,客户端调用 builder 对象的与 setter 相似方法来设置你想设置的可选参数。最后,客户端调用builder对象的一个无参的 build 方法来生成对象,该对象通常是不可变的。Builder 通常是它所构建的类的一个静态成员类(详见第 24 条)。以下是它在实践中的示例:

   // Builder 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 static class Builder {
    // Required parameters
    private final int servingSize;
    private final int servings;

    // Optional parameters - initialized to default values
    private int calories = 0;
    private int fat = 0;
    private int sodium = 0;
    private int carbohydrate = 0;

    public Builder(int servingSize, int servings) {
    this.servingSize = servingSize;
    this.servings = servings;
    }

    public Builder calories(int val) { 
    calories = val; 
    return this;
    }

    public Builder fat(int val) { 
    fat = val; 
    return this;
    }

    public Builder sodium(int val) { 
    sodium = val; 
    return this; 
    }

    public Builder carbohydrate(int val) { 
    carbohydrate = val; 
    return this; 
    }

    public NutritionFacts build() {
    return new NutritionFacts(this);
    }
    }

    private NutritionFacts(Builder builder) {
    servingSize = builder.servingSize;
    servings = builder.servings;
    calories = builder.calories;
    fat = builder.fat;
    sodium = builder.sodium;
    carbohydrate = builder.carbohydrate;
    }
   }

  NutritionFacts 类是不可变的,所有的参数默认值都在一个地方。builder 的 setter 方法返回 builder 本身,这样就可以进行链式调用,从而生成一个流畅的 API。下面是客户端代码的示例:

   NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8)
    .calories(100).sodium(35).carbohydrate(27).build();

  这个客户端代码很容易编写,更重要的是易于阅读。 采用Builder 模式模拟实现的的可选参数可以在Python和Scala都可以找到。

  为了简洁起见,省略了有效性检查。 要尽快检测无效参数,检查 builder 的构造方法和方法中的参数有效性。 在 build 方法调用的构造方法中检查包含多个参数的不变性。为了确保这些不变性不受攻击,在从 builder 复制参数后对对象属性进行检查(详见第 50 条)。 如果检查失败,则抛出 IllegalArgumentException 异常(详见第 72 条),其详细消息指示哪些参数无效(详见第 75 条)。

  Builder 模式非常适合类层次结构。 使用平行层次的 builder,每个builder嵌套在相应的类中。 抽象类有抽象的 builder;具体的类有具体的 builder。 例如,考虑代表各种比萨饼的根层次结构的抽象类:

   // Builder pattern for class hierarchies
   import java.util.EnumSet;
   import java.util.Objects;
   import java.util.Set;

   public abstract class Pizza {
    public enum Topping 
    final Set<Topping> toppings;

    abstract static class Builder<T extends Builder<T>> {
    EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);

    public T addTopping(Topping topping) {
    toppings.add(Objects.requireNonNull(topping));
    return self();
    }

    abstract Pizza build();

    // Subclasses must override this method to return "this"
    protected abstract T self();
    }

    Pizza(Builder<?> builder) {
    toppings = builder.toppings.clone(); // See Item 50
    }
   }

  请注意,Pizza.Builder 是一个带有递归类型参数( recursive type parameter)(详见第 30 条)的泛型类型。 这与抽象的 self 方法一起,允许方法链在子类中正常工作,而不需要强制转换。 Java 缺乏自我类型的这种变通解决方法被称为模拟自我类型(simulated self-type)。

  这里有两个具体的 Pizza 的子类,其中一个代表标准的纽约风格的披萨,另一个是半圆形烤乳酪馅饼。前者有一个所需的尺寸参数,而后者则允许指定酱汁是否应该在里面或在外面:

   import java.util.Objects;

   public class NyPizza extends Pizza {
    public enum Size 
    private final Size size;

    public static class Builder extends Pizza.Builder<Builder> {
    private final Size size;

    public Builder(Size size) {
    this.size = Objects.requireNonNull(size);
    }

    @Override public NyPizza build() {
    return new NyPizza(this);
    }

    @Override protected Builder self() {
    return this;
    }
    }

    private NyPizza(Builder builder) {
    super(builder);
    size = builder.size;
    }
   }

   public class Calzone extends Pizza {
    private final boolean sauceInside;

    public static class Builder extends Pizza.Builder<Builder> {
    private boolean sauceInside = false; // Default

    public Builder sauceInside() {
    sauceInside = true;
    return this;
    }

    @Override public Calzone build() {
    return new Calzone(this);
    }

    @Override protected Builder self() {
    return this; 
    }
    }

    private Calzone(Builder builder) {
    super(builder);
    sauceInside = builder.sauceInside;
    }
   }

  请注意,每个子类 builder 中的 build 方法被声明为返回正确的子类:NyPizza.Builderbuild 方法返回 NyPizza,而 Calzone.Builder 中的 build 方法返回 Calzone。 这种技术,其一个子类的方法被声明为返回在超类中声明的返回类型的子类型,称为协变返回类型(covariant return typing)。 它允许客户端使用这些 builder,而不需要强制转换。

  这些「分层 builder(hierarchical builders)」的客户端代码基本上与简单的 NutritionFacts builder 的代码相同。为了简洁起见,下面显示的示例客户端代码假设枚举常量的静态导入:

   NyPizza pizza = new NyPizza.Builder(SMALL)
    .addTopping(SAUSAGE).addTopping(ONION).build();
   Calzone calzone = new Calzone.Builder()
    .addTopping(HAM).sauceInside().build();

  builder 对构造方法的一个微小的优势是,builder 可以有多个可变参数,因为每个参数都是在它自己的方法中指定的。或者,builder 可以将传递给多个调用的参数聚合到单个属性中,如前面的 addTopping 方法所演示的那样。

  Builder 模式非常灵活。 单个 builder 可以重复使用来构建多个对象。 builder 的参数可以在构建方法的调用之间进行调整,以改变创建的对象。 builder 可以在创建对象时自动填充一些属性,例如每次创建对象时增加的序列号。

  Builder 模式也有缺点。为了创建对象,首先必须创建它的 builder。虽然创建这个 builder 的成本在实践中不太可能被注意到,但在看中性能的场合下这可能就是一个问题。而且,builder 模式比伸缩构造方法模式更冗长,因此只有在有足够的参数时才值得使用它,比如四个或更多。但是请记住,你可能在以后会想要添加更多的参数。但是,如果你一开始是使用的构造方法或静态工厂,当类演化到参数数量失控的时候再转到Builder模式,过时的构造方法或静态工厂就会面临尴尬的处境。因此,通常最好从一开始就创建一个 builder。

  总而言之,当设计类的构造方法或静态工厂的参数超过几个时,Builder 模式是一个不错的选择,特别是如果许多参数是可选的或相同类型的。builder模式客户端代码比使用伸缩构造方法(telescoping constructors)更容易读写,并且builder模式比 JavaBeans 更安全。

文章列表

更多推荐

更多
  • Spark编程-结构化流式编程指南 概述,简单例子,编程模型,使用 Dataset 和 DataFrame 的API,连续处理,额外信息,基本概念,处理 Eventtime 和 Late Data,faulttolerance 语义,创建流式 DataFrame 和流式
  • Spark编程-20 Spark 配置Spark 属性,Environment Variables环境变量,Configuring Logging配置 Logging,Overriding configuration directory覆盖配置目录,Inhe
  • Spark编程-在Mesos上运行Spark 运行原理,安装 Mesos,连接 Spark 到 Mesos,Mesos 运行模式,Mesos Docker 支持,集成 Hadoop 运行,使用 Mesos 动态分配资源,配置,故障排查和调试,从源码安装,第三方软件包,验证,上传 S
  • Spark编程-Running Spark on YARN 启动 Spark on YARN,准备,配置,调试应用,在安全集群中运行,添加其他的 JARs,配置外部的 Shuffle Service,用 Apache Oozie 来运行应用程序,Kerberos 故障排查,使用 Spark Hi
  • Spark编程-Spark 调优 数据序列化,内存调优,其它考虑,,内存管理概论,确定内存消耗,优化数据结构,序列化 RDD 存储,GC优化,并行级别,Reduce任务内存使用,广播大变量,数据局部性, 由于大多数Spark计算都在内存中,所以集群中的任何资源(C
  • Spark编程-Spark Standalone模式 安装 Spark Standalone 集群,手动启动一个集群,集群启动脚本,提交应用程序到集群中,启动 Spark 应用程序,Resource Scheduling资源调度,监控和日志,与 Hadoop 集成,配置网络安全端口,高可用
  • Spark编程-Monitoring and Instrumentation Web 界面,Metrics,高级工具,事后查看,REST API,环境变量,Spark配置选项,API 版本控制策略, 有几种方法来监视 Spark 应用程序:Web UI,metrics 和外部工具。 Web 界面每
  • Spark编程-Spark提交任务Submitting Applications 打包应用依赖,用 sparksubmit 启动应用,Master URLs,从文件中加载配置,高级的依赖管理,更多信息, 在 script in Spark的 `bin` 目录中的`spark-submit` 脚本用与在集群上启动
  • Spark编程-作业调度 概述,跨应用调度,应用内调度,动态资源分配,公平调度资源池,资源池默认行为,配置资源池属性,配置和部署,资源分配策略,优雅的关闭Executor(执行器),概述Spark 有好几计算资源调度的方式。首先,回忆一下 [集群
  • Spark编程-Spark 概述 安全,下载,运行示例和 Shell,在集群上运行,进一步学习链接, Apache Spark 是一个快速的,通用的集群计算系统。它对 Java,Scala,Python 和 R 提供了的高层 API,并有一个经优化的支持通用执行图
  • 近期文章

    更多
    文章目录

      推荐作者

      更多