Java - 用builder代替构造器

静态工厂和够构造器有一个共同的局限性：遇到大量的参数时无法很好的扩展。

先说说构造器。
其实field不多时重叠构造器(telescoping constructor)是个不错的方法，易于编写也易于调用，这种方式在参数数量较少时也很常见。
但问题是参数很多(可能越来越多)时，比如(现在已经很难找到对多个参数进行重叠构造的代码了，于是在这里直接引用一下书中的代码)：

public class NutritionFacts {

    private final int servingSize; // (mL) required

    private final int servings; // (per container) required

    private final int calories; // optional

    private final int fat; // (g) optional

    private final int sodium; // (mg) optional

    private final int carbohydrate; // (g) 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;

    }

}

我想创建实例的时候，代码会变成这个样子：

public static void main(String[] args) {

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

}

为了让创建实例的过程变得更加清晰，于是我们有另一中选择——JavaBean模式。
这个再熟悉不过了，如下：

public class NutritionFacts {

    // Parameters initialized to default values (if any)

    private int servingSize = -1;

    private int servings = -1;

    private int calories = 0;

    private int fat = 0;

    private int sodium = 0;

    private int carbohydrate = 0;

    public NutritionFacts() {

    }

    // Setters

    public void setServingSize(int val) {

        servingSize = val;

    }

    public void setServings(int val) {

        servings = val;

    }

    public void setCalories(int val) {

        calories = val;

    }

    public void setFat(int val) {

        fat = val;

    }

    public void setSodium(int val) {

        sodium = val;

    }

    public void setCarbohydrate(int val) {

        carbohydrate = val;

    }

}

用起来虽然比只有一行的构造器多几个步骤，但非常清晰：

public static void main(String[] args) {

    NutritionFacts cocaCola = new NutritionFacts();

    cocaCola.setServingSize(240);

    cocaCola.setServings(8);

    cocaCola.setCalories(100);

    cocaCola.setSodium(35);

    cocaCola.setCarbohydrate(27);

}

相比只通过一个构造器创建实例，JavaBean模式的实例的构造过程被分成了好几个过程。
我们完全有可能在属性不完整的情况下使用这个实例。
按书中原文就是:

A JavaBean may be in a inconsistent state partway through its construction.

当然，我们也可以做一些操作使其在未完成的情况下无法使用，但我不想因此让一个类变得越来越复杂。
另外，我根本无法用JavaBean模式完全排除了将类设计成不可变(Immutable)的可能性。

此时，我们选择使用Builder来解决这一问题。
示例如下：

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 carbohydrate = 0;

        private int sodium = 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 carbohydrate(int val) {

            carbohydrate = val;

            return this;

        }

        public Builder sodium(int val) {

            sodium = 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;

    }

}

调用起来非常清晰(模拟了具名参数)，而且非常简单：

public static void main(String[] args) {

    NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8)

                .calories(100).sodium(35).carbohydrate(27).build();

}

当然，Builder也有缺点。

创建实例前都要创建一个Builder实例。
Builder模式编写起来较为冗长。

但是，当构建一个实例需要很多步骤(或者很多让人混淆的参数)的时候，Builder模式是个不错的选择。

巴特西

Java - 用builder代替构造器

最新文章

热门文章