其他分享
首页 > 其他分享> > 设计模式之【建造者模式】

设计模式之【建造者模式】

作者:互联网

设计原则是指导我们代码设计的一些经验总结,也就是“心法”;面向对象就是我们的“武器”;设计模式就是“招式”。

以心法为基础,以武器运用招式应对复杂的编程问题。

为什么麦当劳那么受欢迎?

表妹:哥啊,我想吃麦当劳

我:你为啥那么喜欢吃麦当劳呢?

表妹:因为它好吃呀,而且每个门店吃的味道都差不多,不像某县小吃,每个地方吃的味道都有区别。

我:那你知道为什么嘛?

表妹:因为麦当劳有一套非常完善的工作流程,每个门店都必须遵守这套规范...

这不就是我们设计模式中的【建造者模式】嘛?


将一个复杂对象的构造与它的表示分离,使同样的构建过程可以创建不同的表示。

我们以煲汤为例子,我们知道,主汤料和水是煲汤必须的,配料是可放可不放的,有些人喜欢吃原汁原味,可以不放盐,有些肉比较油,那么,也可以不放油。

我们来看看具体的代码实现:

 1 public class Soup {
 2     private static final int MAX_INGREDIENTS = 10;
 3     private static final int MAX_OIL = 8;
 4     private static final int MAX_SALT = 5;
 5     
 6     private String mainIngredient;  // 主料必须
 7     private String water;           // 水必须
 8     private int ingredients;        // 配料可选
 9     private int oil;                // 油可选
10     private int salt;               // 盐可选
11     
12     public Soup(String main, String water, Integer ingredients, Integer oil, Integer salt) {
13         if (StringUtils.isBlank(main)) {
14             throw new IllegalArgumentException("main should not be empty");
15         }
16         this.mainIngredient = main;
17     
18         if (StringUtils.isBlank(water)) {
19             throw new IllegalArgumentException("water should not be empty");
20         }
21         this.water = water;
22     
23         if (ingredients != null) {
24             if (ingredients < 0) {
25                 throw new IllegalArgumentException("ingredients should not be positive");
26             }
27             this.ingredients = ingredients;
28         }
29         
30         if (oil != null) {
31             if (oil < 0) {
32                 throw new IllegalArgumentException("oil should not be positive");
33             }
34             this.oil = oil;
35         }
36         
37         if (salt != null) {
38             if (salt < 0) {
39                 throw new IllegalArgumentException("salt should not be positive");
40             }
41             this.salt = salt;
42         }
43     }
44     
45     // 省略get方法
46 }
47 ​
48 // 今天想吃鱼头豆腐汤
49 Soup fishHeadTofuSoup = new Soup("鱼头", "山泉水", 10, 6, 3);

大家可以看到,这个构造函数有5个参数,参数列表太长,导致代码在可读性和易用性上都会变差。

而且这么长的参数列表,参数类型一样的都连在一起,在使用构造函数的时候,就很容易搞错各参数的顺序,传递进错误的参数值,导致非常隐蔽的bug。上面这个例子中,配料和盐都是int类型,万一我一不小心,把这两个参数的位置互换了,变成放3克的配料,放10克的盐,那还能吃嘛?

有些同学可能会说,你这个类在构造对象的时候,有些属性是可选可不选的,这些属性可以通过set()函数来设置。

是的,我们来看一下,这种方法的实现效果:

 1 public class Soup {
 2     private static final int MAX_INGREDIENTS = 10;
 3     private static final int MAX_OIL = 8;
 4     private static final int MAX_SALT = 5;
 5     
 6     private String mainIngredient;  // 主料必须
 7     private String water;           // 水必须
 8     private int ingredients;        // 配料可选
 9     private int oil;                // 油可选
10     private int salt;               // 盐可选
11     
12     public Soup(String main, String water) {
13         if (StringUtils.isBlank(main)) {
14             throw new IllegalArgumentException("main should not be empty");
15         }
16         this.mainIngredient = main;
17     
18         if (StringUtils.isBlank(water)) {
19             throw new IllegalArgumentException("water should not be empty");
20         }
21         this.water = water;
22     }
23     
24     public void setIngredients(int ingredients) {
25         if (ingredients != null) {
26             if (ingredients < 0) {
27                 throw new IllegalArgumentException("ingredients should not be positive");
28             }
29             this.ingredients = ingredients;
30         }
31     }
32      
33     public void setOil(int oil) {
34         if (oil != null) {
35             if (oil < 0) {
36                 throw new IllegalArgumentException("oil should not be positive");
37             }
38             this.oil = oil;
39         }
40     }
41     
42     public void setSalt(int salt) {
43         if (salt != null) {
44             if (salt < 0) {
45                 throw new IllegalArgumentException("salt should not be positive");
46             }
47             this.salt = salt;
48         }
49     }
50     
51     // 省略get方法
52 }
53 ​
54 // 今天想吃菌菇乌鸡汤
55 Soup blackChickenSoup = new Soup("乌鸡", "水");
56 blackChickenSoup.setIngredients(8);
57 blackChickenSoup.setOil(5);
58 blackChickenSoup.setSalt(3);

这样一看,确实构造函数的参数列表变短了,也能够煲出美味的汤。但是,还是存在下面几个问题:

1、上面的例子中,只有两个必填的属性,但是如果必填的属性有很多呢?把这些必填属性都放到构造函数中设置,那岂不是又是一个很长的参数列表呢?

2、如果我们把必填属性也通过set()方法设置,那校验这些必填属性是否已经填写的逻辑就无处安放了。

3、如果属性之间有一定的依赖关系,比如,如果煲汤者放了配料ingredients,那么就一定要放盐salt;或者属性之间有一定的约束条件,比如,配料的克数要大于盐的克数。如果我们继续使用现在的设计思路,那这些属性之间的依赖关系或者约束关系的校验逻辑就无处安放了。

4、如果我们希望Soup类对象是不可变对象,也就是说,对象在创建好之后,就不能再修改内部的属性值了。那么,我们就不能在类中暴露set()方法了。

5、如果这些属性不是一起初始化的话,就会导致对象的无效状态。何为无效状态呢?一起看看下面的代码:

1 Rectangle r = new Rectangle();  // 此时r是无效对象,因为长方形必须有长宽值。
2 r.setWidth(2);  // 此时r还是无效状态
3 r.setHeight(4); // 此时的r设置好了长宽值,才是有效状态

这时候,建造者模式就派上用场啦~

建造者模式

1、在Soup类中创建一个静态内部类Builder,然后将Soup类中的参数都复制到Builder类中。

2、在Soup类中创建一个private的构造函数,参数为Builder类型。

3、在Builder中创建一个public的构造函数,参数为Soup中必填的参数,mainIngredient和water。

4、在Builder中创建set()方法,对Soup中那些可选参数进行赋值,返回值为Builder类型的实例。

5、在Builder中创建一个build()方法,在其中创建Soup的实例并返回。

  1 public class Soup {
  2     private String mainIngredient;
  3     private String water;
  4     private int ingredient;
  5     private int oil;
  6     private int salt;
  7     
  8     private Soup(Builder builder) {
  9         this.mainIngredient = builder.mainIgredient;
 10         this.water = builder.water;
 11         this.ingredients = builder.ingredients;
 12         this.oil = builder.oil;
 13         this.salt = builder.salt;
 14     }
 15     // 省略get方法
 16     
 17     // 将Builder类设计成Soup的内部类
 18     // 也可以将BUilder类设计成独立的非内部类SoupBuilder
 19     public static class Builder {
 20         private static final int MAX_INGREDIENTS = 10;
 21         private static final int MAX_OIL = 8;
 22         private static final int MAX_SALT = 5;
 23         
 24         private String mainIngredient;
 25         private String water;
 26         private int ingredient;
 27         private int oil;
 28         private int salt;
 29         
 30         public Soup build() {
 31             // 校验逻辑放到这里做,包括必填项校验,依赖关系校验,约束条件校验等
 32             // 主料必填
 33             if (StringUtils.isBlank(mainIngredient)) {
 34                 throw new IllegalArgumentException("...");
 35             }
 36             // 水必填
 37             if (StringUtils.isBlank(water)) {
 38                 throw new IllegalArgumentException("...");
 39             }
 40             // 依赖关系:如果放了配料,就一定要放盐
 41             if (ingredients > 0 && salt <= 0) {
 42                 throw new IllegalArgumentException("...");
 43             }
 44             // 约束条件:配料的克数不能小于等于盐的克数
 45             if (ingredients <= salt) {
 46                 throw new IllegalArgumentException("...");
 47             }
 48             
 49             return new Soup(this);
 50         }
 51         
 52         public Builder setMainIngredients(String mainIngredient) {
 53             if (StringUtils.isBlank(mainIngredient)) {
 54                 throw new IllegalArgumentException("...");
 55             }
 56             this.mainIngredient = mainIngredient;
 57             return this;
 58         }
 59  
 60         public Builder setWater(String water) {
 61             if (StringUtils.isBlank(water)) {
 62                 throw new IllegalArgumentException("...");
 63             }
 64             this.water = water;
 65             return this;
 66         }
 67         
 68         public Builder setIngredients(int ingredients) {
 69             if (ingredients != null) {
 70                 if (ingredients < 0) {
 71                     throw new IllegalArgumentException("ingredients should not be positive");
 72                 }
 73                 this.ingredients = ingredients;
 74             }
 75             return this;
 76         }
 77      
 78         public Builder setOil(int oil) {
 79             if (oil != null) {
 80                 if (oil < 0) {
 81                     throw new IllegalArgumentException("oil should not be positive");
 82                 }
 83                 this.oil = oil;
 84             }
 85             return this;
 86         }
 87 ​
 88         public Builder setSalt(int salt) {
 89             if (salt != null) {
 90                 if (salt < 0) {
 91                     throw new IllegalArgumentException("salt should not be positive");
 92                 }
 93                 this.salt = salt;
 94             }
 95             return this;
 96         }
 97     }
 98 }
 99 ​
100 // 今天吃冬瓜排骨汤
101 Soup winterMelonRibSoup = new Soup.Builder()
102     .setMainIngredients("排骨")
103     .setWater("山泉水")
104     .setIngredients(8)   // 冬瓜8克
105     .setOil(2)
106     .setSalt(3)
107     .builder();

你看,这样设计的话,上面的5个问题都解决了。

大家发现没有,一份美味的汤是由主料、水、配料、油和盐多个简单的对象组成的,然后一步一步构建而成。而建造者模式将变与不变分离,即汤的组成部分是不变的,但每一部分是可以灵活选择的。

像上面煲的冬瓜排骨汤,如果我忘记放油了:

1 Soup winterMelonRibSoup = new Soup.Builder()
2     .setMainIngredients("排骨")   // 第一步
3     .setWater("山泉水")
4     .setIngredients(8)   // 冬瓜8克
5     // .setOil(2)        // 不放油
6     .setSalt(3)       
7     .builder();

这样并不会导致状态的无效状态,没有显示设置会自动初始化为默认值。那么,煲出来的味道就不一样了。

可能有人会问,上面定义说“将一个复杂对象的构建与其表示分离,使得同样的构建过程可以创建不同的表示”,但你这也没有实现将构建与表示分离,而且是不同的构建过程创建出不同的表示。

是的,同样的构建过程就相当于麦当劳规范的制作流程,如果按照这套构建过程来构建对象,就不会忘记“放油”了。如下图所示:

 

其实,上面是Builder在Java中一种简化的使用方式,经典的Builder模式还是有点不同的。

经典Builder模式

它有4个角色:

接下来我们看一下具体的代码实现:

第一步:我们的目标Soup类:

 1 public class Soup {
 2     private static final int MAX_INGREDIENTS = 10;
 3     private static final int MAX_OIL = 8;
 4     private static final int MAX_SALT = 5;
 5     
 6     private String mainIngredient;  // 主料必须
 7     private String water;           // 水必须
 8     private int ingredients;        // 配料可选
 9     private int oil;                // 油可选
10     private int salt;               // 盐可选
11     
12     public Soup(String main, String water) {
13         if (StringUtils.isBlank(main)) {
14             throw new IllegalArgumentException("main should not be empty");
15         }
16         this.mainIngredient = main;
17     
18         if (StringUtils.isBlank(water)) {
19             throw new IllegalArgumentException("water should not be empty");
20         }
21         this.water = water;
22     }
23     
24     public void setIngredients(int ingredients) {
25         if (ingredients != null) {
26             if (ingredients < 0) {
27                 throw new IllegalArgumentException("ingredients should not be positive");
28             }
29             this.ingredients = ingredients;
30         }
31     }
32      
33     public void setOil(int oil) {
34         if (oil != null) {
35             if (oil < 0) {
36                 throw new IllegalArgumentException("oil should not be positive");
37             }
38             this.oil = oil;
39         }
40     }
41     
42     public void setSalt(int salt) {
43         if (salt != null) {
44             if (salt < 0) {
45                 throw new IllegalArgumentException("salt should not be positive");
46             }
47             this.salt = salt;
48         }
49     }
50     
51     // 省略get方法
52 }

第二步:抽象建造者类

1 public abstract class SoupBuilder {
2     public abstract void setIngredients();
3     public abstract void setSalt();
4     public abstract void setOil();
5     
6     public abstract Soup getSoup();
7 }

第三步:实体建造者类,我们可以根据要构建的产品种类产生多个实体建造者类,这里我们构建两种汤,鱼头豆腐汤和冬瓜排骨汤。所以,我们生成了两个实体建造者类。

鱼头豆腐汤建造者类:

 1 public class FishHeadTofuSoupBuilder extends SoupBuilder {
 2     private Soup soup;
 3     public (String mainIngredient, String water) {
 4         soup = new Soup(mainIngredient, water);
 5     }
 6     @Override
 7     public void setIngredients() {
 8         soup.setIngredients(10);
 9     }
10     @Override 
11     public void setSalt() {
12         soup.setSalt(3);
13     }
14     @Override 
15     public void setOil() {
16         soup.setOil(4);
17     }
18     
19     @Override 
20     public Soup getSoup() {
21         return soup;
22     }
23 }

冬瓜排骨汤建造者类:

 1 public class WinterMelonRibSoupBuilder extends SoupBuilder {
 2     private Soup soup;
 3     public (String mainIngredient, String water) {
 4         soup = new Soup(mainIngredient, water);
 5     }
 6     @Override
 7     public void setIngredients() {
 8         soup.setIngredients(7);
 9     }
10     @Override 
11     public void setSalt() {
12         soup.setSalt(2);
13     }
14     @Override 
15     public void setOil() {
16         soup.setOil(3);
17     }
18     
19     @Override 
20     public Soup getSoup() {
21         return soup;
22     }
23 }

第四步:指导者类(Director)

1 public class SoupDirector {
2     public void makeSoup(SoupBuilder builder) {
3         // 一套规范的流程
4         builder.setIngredients();
5         builder.setSalt();
6         builder.setOil();
7     }
8 }

指导者类SoupDirector在Builder模式中具有很重要的作用,它用于指导具体构建者如何构建产品,控制调用先后顺序。这也就是定义中所说的“使用同样的构建过程”。

那么,我们来看一下,客户端如何构建对象呢?

 1 public static void main(String[] args) {
 2     SoupDirector director = new SoupDirector();
 3     SoupBuilder builder = new FishHeadTofuSoupBuilder("鱼头", "水");
 4     // 按照那套规范流程来煲汤
 5     director.makeSoup(builder);
 6     // 鱼头豆腐汤出锅
 7     Soup fishHeadTofuSoup = builder.getSoup();
 8     
 9     // 现在我想喝冬瓜排骨汤
10     SoupBuilder winterMelonRibSoupBuilder = new WinterMelonRibSoupBuilder("排骨", "山泉水");
11     // 按照那套规范流程来煲汤
12     director.makeSoup(winterMelonRibSoupBuilder);
13     // 冬瓜排骨汤出锅
14     Soup winterMelonRibSoup = winterMelonRibSoupBuilder.getSoup();
15 }

建造者模式的优点

建造者模式的缺点

建造者模式与工厂模式的区别

通过前面的学习,我们一起来看看,建造者模式和工厂方法模式有什么区别:

在工厂方法模式中,我们关注的是一个产品整体,比如tank整体,无需关心tank的各个部分是如何创建出来的;但在建造者模式中,一个具体产品的产生,是依赖各个部件的产生以及装配顺序的,它关注的是“由零件一步一步地组装出产品对象”。简单地说,工厂模式是一个对象创建的粗线条应用,建造者模式则是通过细线条勾勒出一个复杂对象,关注的是产品组成部分的创建过程。

工厂方法模式创建的产品一般都是单一性质的产品,比如tank,都具有一个方法attack(),而建造者模式创建的则是一个复合产品,它由各个部件复合而成,部件不同产品对象当然不同。这不是说工厂方法模式创建的对象简单,而是指它们的粒度大小不同。一般来说,工厂方法模式的对象粒度比较粗,建造者模式的产品对象粒度比较细。

建造者模式的应用场景

当需要创建的产品具备复杂创建过程时,可以抽取出共性创建过程,然后交由具体实现类自定义创建流程,使得同样的创建行为可以生产出不同的产品,分离了创建与表示,使创建产品的灵活性大大增加。

建造者模式主要适用于以下场景:

总结

建造者模式用来创建复杂对象,可以通过设置不同的可选参数,“定制化”地创建不同的对象。

参考

极客时间专栏《设计模式之美》

https://www.cnblogs.com/ChinaHook/p/7471470.html

https://zhuanlan.zhihu.com/p/58093669

标签:int,建造,private,water,Soup,模式,设计模式,salt,public
来源: https://www.cnblogs.com/Gopher-Wei/p/15971144.html