简说设计模式——建造者模式

一、什么是建造者模式

  我们先说一个生活中的小例子,当我们在外面饭店吃饭时,比如点个水煮肉片,这家店可能会辣一点、那家店可能会咸一点、对面那家可能放青菜、隔壁那家可能放菠菜,每家店做出来的都不一样,明明都是水煮肉片却有不同的做法,如果都一样就不会说这家难吃那家好吃了。那再看快餐店,比如KFC,我们点个至尊虾堡,所有人不管在哪个城市哪家店,做法、味道都是一样的,为什么呢,因为它用料、时间、温度等等都是严格规定的,我们只需要下订单就行了,这就是一个建造者模式。

       建造者模式(Builder),将一个复杂的对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。UML结构图如下:

       其中,Director为指挥者/导演类,负责安排已有模块的顺序,然后告诉Builder开始建造;Builder是抽象建造者,规范产品的组建,一般由子类实现;ConcreteBuilder是具体建造者,实现抽象类定义的所有方法,并且返回一个组建好的对象;Product是产品类,通常实现了模板方法模式。

    1. Director类

       导演类起到封装的作用,避免高层模块深入到建造者内部的实现类。在建造者模式比较庞大时,导演类可以有多个。

1 public class Director {
2     
3     public void Construct(Builder builder) {
4         builder.BuildPartA();
5         builder.BuildPartB();
6     }
7 
8 }

    2. Builder类

       抽象建造者类,确定产品由两个部件PartA和PartB组成,并声明一个得到产品建造后结果的方法getResult()。

public abstract class Builder {
    
    public abstract void BuildPartA();        //产品的A部件
    public abstract void BuildPartB();        //产品的B部件
    public abstract Product getResult();    //获取产品建造后结果

}

    3. ConcreteBuilder类

       具体建造者类,有几个产品类就有几个具体的建造者,而且这多个产品类具有相同的接口或抽象类。这里给出一个产品类的样例,多个产品类同理。

 1 public class ConcreteBuilder1 extends Builder {
 2 
 3     private Product product = new Product();
 4     
 5     //设置产品零件
 6     @Override
 7     public void BuildPartA() {
 8         product.add("部件A");
 9     }
10 
11     @Override
12     public void BuildPartB() {
13         product.add("部件B");
14     }
15 
16     //组建一个产品
17     @Override
18     public Product getResult() {
19         return product;
20     }
21 
22 }

    4. Client客户端

 1 public class Client {
 2 
 3     public static void main(String[] args) {
 4         
 5         Director director = new Director();
 6         Builder builder1 = new ConcreteBuilder1();
 7         Builder builder2 = new ConcreteBuilder2();
 8         
 9         //指挥者用ConcreteBuilder1的方法来建造产品
10         director.Construct(builder1);
11         Product product1 = builder1.getResult();
12         product1.show();
13         
14         //指挥者用ConcreteBuilder2的方法来建造产品
15         director.Construct(builder2);
16         Product product2 = builder2.getResult();
17         product2.show();
18         
19     }
20     
21 }

       运行结果如下:

二、建造者模式的应用

    1. 何时使用

  • 一个基本部件不会变,而其组合经常变化的时候

    2. 优点

  • 封装性。是客户端不必知道产品内部组成的细节。
  • 建造者独立,易扩展。
  • 便于控制细节风险。可以对建造过程逐步细化,而不对其他模块产生任何影响。

    3. 缺点

  • 产品必须有共同点,范围有限制。
  • 如果内部变化复杂,会有很多建造类。

    4. 使用场景

  • 相同的方法,不同的执行顺序,产生不同的事件结果时。
  • 需要生成的对象具有复杂的内部结构时。
  • 多个部件或零件,都可以装配到一个对象中,但产生的结果又不相同时。

    5. 与工厂模式的区别

  • 建造者模式更关注于零件装配的顺序

    6. 应用实例

  • KFC的食品制作流程,原料多少克、加热几分钟等都有严格的规定,我们只需点餐即可,无论在哪里点的都是一样的。
  • 去KFC吃汉堡、薯条、炸鸡等,这些单品是不变的,其组合是经常改变的,也就是所谓的“套餐”。
  • Java中的StringBuilder/StringBuffer。

三、建造者模式的实现

       下面我们看一个KFC点套餐的例子,我们点餐可以点一个汉堡和一个冷饮,汉堡可以是鸡肉汉堡、虾堡等等,是装在盒子中的,冷饮可以是可乐、雪碧等等,是装在瓶子中的。下面我们来用建造者模式对其进行组合,用户只需提交订单即可,UML图如下:

    1. Item接口

       创建一个表示食物条目和食物包装的接口。

 1 public interface Item {
 2 
 3     //获取食物名称
 4     public String getName();
 5     //获取包装
 6     public Packing packing();
 7     //获取价格
 8     public float getPrice();
 9     
10 }
1 public interface Packing {
2 
3     //获取包装类型
4     public String getPack();
5     
6 }

    2. 包装类

       实现Packing接口的实现类。Wapper为纸盒包装,Bottle为瓶装。

1 public class Wrapper implements Packing {
2 
3     @Override
4     public String getPack() {
5         return "纸盒";
6     }
7 
8 }
1 public class Bottle implements Packing {
2 
3     @Override
4     public String getPack() {
5         return "纸杯";
6     }
7 
8 }

    3. 食品类

       创建实现Item接口的抽象类。Burger为汉堡,Drink为饮品。

 1 public abstract class Burger implements Item {
 2 
 3     @Override
 4     public Packing packing() {
 5         return new Wrapper();
 6     }
 7     
 8     @Override
 9     public abstract float getPrice();
10     
11 }
 1 public abstract class Drink implements Item {
 2 
 3     @Override
 4     public Packing packing() {
 5         return new Bottle();
 6     }
 7     
 8     @Override
 9     public abstract float getPrice();
10     
11 }

    4. 具体食品类

       创建扩展了Burger和Drink的具体实现类。这里简单的就设为Burger1、Burger2、Drink1、Drink2。各写一个,多余的就不赘述了。

 1 public class Burger1 extends Burger {
 2 
 3     @Override
 4     public String getName() {
 5         return "汉堡1";
 6     }
 7 
 8     @Override
 9     public float getPrice() {
10         return 25.0f;
11     }
12 
13 }
 1 public class Drink1 extends Drink {
 2 
 3     @Override
 4     public String getName() {
 5         return "饮品1";
 6     }
 7 
 8     @Override
 9     public float getPrice() {
10         return 15.0f;
11     }
12 
13 }

    5. Meal类

 1 public class Meal {
 2     
 3     private List<Item> items = new ArrayList<>();
 4     
 5     public void addItem(Item item) {
 6         items.add(item);
 7     }
 8     
 9     //获取总消费
10     public float getCost() {
11         float cost = 0.0f;
12         
13         for (Item item : items) {
14             cost += item.getPrice();
15         }
16         
17         return cost;
18     }
19     
20     public void showItem() {
21         for (Item item : items) {
22             System.out.print("餐品:" + item.getName());
23             System.out.print(",包装:" + item.packing().getPack());
24             System.out.println(",价格:¥" + item.getPrice());
25         }
26     }
27 
28 }

    6. 指挥者

 1 public class MealBuilder {
 2 
 3     //订单1
 4     public Meal order1() {
 5         Meal meal = new Meal();
 6         meal.addItem(new Burger1());
 7         meal.addItem(new Drink1());
 8         
 9         return meal;
10     }
11     
12     //订单2
13     public Meal order2() {
14         Meal meal = new Meal();
15         meal.addItem(new Burger2());
16         meal.addItem(new Drink2());
17         
18         return meal;
19     }
20     
21 }

    7. Client客户端

 1 public class Client {
 2 
 3     public static void main(String[] args) {
 4         MealBuilder mealBuilder = new MealBuilder();
 5         
 6         //获取第一个订单
 7         Meal order1 = mealBuilder.order1();
 8         System.out.println("------order1------");
 9         order1.showItem();
10         System.out.println("总额:¥" + order1.getCost());
11         
12         //获取第二个订单
13         Meal order2 = mealBuilder.order2();
14         System.out.println("------order2------");
15         order2.showItem();
16         System.out.println("总额:¥" + order2.getCost());
17     }
18     
19 }

       运行结果如下:

 

       源码地址:https://gitee.com/adamjiangwh/GoF

posted @ 2018-04-27 23:27 JAdam 阅读(...) 评论(...) 编辑 收藏