遇到多个构造器参数时要考虑用构建器(Builder)

发表于 | 分类于

场景一

使用静态工厂或者构造器都有共同的局限性：它们都不能很好地扩展大量的可选参数。
来看一下GsonBuilder的使用

1
2
3
4
5
6
7
8
9
Gson gson = new GsonBuilder()
.registerTypeAdapter(Id.class, new IdTypeAdapter())   
.enableComplexMapKeySerialization()
.serializeNulls()   
.setDateFormat(DateFormat.LONG)  
.setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE)
.setPrettyPrinting()
.setVersion(1.0)    
.create();

我们先构造一个新的GsonBuilder，将需要的参数导入后，通过create()方法创建一个Gson对象gson供我们使用。

场景二

现在看一下《Effective Java》书中的Builder的例子，场景如下：用一个类表示包装食品外面显示的营养成分标签。这些标签中有几个域是必需的：每份的含量、每罐的含量以及每份的卡路里，还有超过20个可选域：总脂肪量、饱和脂肪量、转化脂肪、胆固醇、钠等等。大多数产品在某几个可选域中都会有非零的值。

重叠构造器模式

对于这样的一个类，应该用哪种构造器或者静态方法来编写呢？

程序员一向习惯采用重叠构造器(Telescoping constructor)模式，在这种模式下，你提供第一个只有必要参数的构造器，第二个构造器有必要参数和一个可选参数，第三个构造器有必要参数和两个可选参数，依次类推，最后一个构造器包含所有可选参数。下面有个示例为了简单起见，它只显示四个可选域：


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
/**
 * 食品营养成分标签类  
 */  
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 = calories;  
    }  
}

当想要创建实例的时候，只需使用参数列表最短的构造器，但该列表包含了要设置的所有参数：

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

  • 一句话点评：重叠构造器模式可行，但是当有许多参数的时候，客户代码很难编写，并且仍然较难以阅读。读者必须仔细数着参数个数进行确认，并且同时还要关注参数的顺序。

JavaBean模式

在这种模式下，调用一个无参构造器来创建对象，然后调用setter方法来设置必要的参数，以及每个相关的可选参数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class NutritionFacts {  
    // Parameters initialized to default values (if any)  
    private int servingSize  = -1;  // Required; no default value  
    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可能处于不一致的状态，这样在多线程环境下容易产生线程安全问题。与此相关的，JavaBean模式阻止了把类做成不可变类的可能，这需要我们自己付出额外努力来确保对象的线程安全（手工“冻结”）对象。

Builder模式

不直接生成想要的对象，而是让客户端利用所有必要的参数调用构造器或静态工厂，得到一个builder对象，然后客户端在builder对象上调用类似于setter的方法，来设置每个相关的可选参数。最后，客户端调用无参的build方法来生成不可变的对象。通常，这个builder是它构造的类的静态成员类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
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;  
    }  
}

注意NutritionFacts本身是不可变的，所有默认参数都单独放在一个地方。builder的setter方法返回builder本身，以便可以把调用链接起来。下面就是客户端代码：

1
2
3
4
5
6
NutritionFacts cocaCola = new NutritionFacts
.Builder(240, 8)
.calories(100)
.sodium(35)
.carbohydrate(27)
.build();

优点：
  • 这样的客户端代码很容易编写，更为重要的是，易于阅读。builder模式模拟了具名的可选参数。
  • builder像个构造器一样，可以对其参数强加约束条件。build方法可以检验这些约束条件，将参数从builder拷贝到对象中之后，并在对象域而不是builder域中对它们进行检验，如果违反了任何约束条件，build方法就应该抛出IllegalStateException。异常的详细信息应该显示出了违反了哪个约束条件。除此之外，setter方法也会对参数进行检查，如果约束条件没有满足，setter方法就会抛出IllegalArgumentException。这有个好处，就是一旦传递了无效的参数，立即就会发现约束失败，而不是等着调用build方法。
  • 与构造器相比，builder的略微优势在于，builder可以有多个可变参数。构造器就像方法一样，只能有一个可变参数。因为builder利用单独的方法来设置每个参数，你想要有多少个可变参数，它们就可以有多少个，直到每个setter方法都有一个可变参数。
  • Builder模式十分灵活，可以利用单个builder构建多个对象。builder的参数可以在创建对象期间进行调整，也可以随着不同的对象而改变。builder可以自动填充某些域，例如每次创建对象时自动增加序列号。
缺点：
  • 为了创建对象，必须先创建它的构造器。虽然创建构建器的开销在实践中可能不那么明显，但是在某些十分注重性能的情况下，可能就成问题了。Builder模式还比重叠构造器模式更加冗长，因此它只在有很多参数的时候才使用，比如4个或者更多参数。

但是记住，将来你可能需要添加参数。如果一开始就使用构造器或者静态工厂，等到类需要多个参数时才添加builder，就会无法控制，那些过时的构造器或者静态工厂显得十分不协调。因此，通常最好一开始就使用builder。

简而言之，如果类的构造器或者静态工厂中具有多个参数，设计这种类时，Builder模式就是种不错的选择，特别是当大多数参数都是可选的时候。与使用传统的重叠构造器相比，使用Builder模式的客户端代码将易于阅读和编写，构建器也比JavaBeans更加安全。

------ 本文结束 ------

版权声明


BillyYccc's blog by Billy Yuan is licensed under a Creative Commons BY-NC-SA 4.0 International License.
本文原创于BillyYccc's Blog，转载请注明原作者及出处！