《Dubbo 实现原理与源码解析 —— 精品合集》 《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》 《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》 《数据库实体设计合集》

摘要: 原创出处 http://www.cnblogs.com/chenssy/archive/2013/06/03/3114681.html 「小明哥」欢迎转载,保留摘要,谢谢!


🙂🙂🙂关注**微信公众号:【芋道源码】**有福利:

  1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
  2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
  3. 您对于源码的疑问每条留言将得到认真回复。甚至不知道如何读源码也可以请教噢
  4. 新的源码解析文章实时收到通知。每周更新一篇左右
  5. 认真的源码交流微信群。

在工厂方法模式中,我们使用一个工厂创建一个产品,也就是说一个具体的工厂对应一个具体的产品。但是有时候我们需要一个工厂能够提供多个产品对象,而不是单一的对象,这个时候我们就需要使用抽象工厂模式。

在讲解抽象工厂模式之前,我们需要厘清两个概念:

产品等级结构。产品的等级结构也就是产品的继承结构。例如一个为空调的抽象类,它有海尔空调、格力空调、美的空调等一系列的子类,那么这个抽象类空调和他的子类就构成了一个产品等级结构。

产品族。产品族是在抽象工厂模式中的。在抽象工厂模式中,产品族是指由同一个工厂生产的,位于不同产品等级结构中的一组产品。比如,海尔工厂生产海尔空调。海尔冰箱,那么海尔空调则位于空调产品族中。

产品等级结构和产品族结构示意图如下:

img

一、基本定义

抽象工厂模式提供一个接口,用于创建相关或者依赖对象的家族,而不需要明确指定具体类。

抽象工厂允许客户端使用抽象的接口来创建一组相关的产品,而不需要关系实际产出的具体产品是什么。这样一来,客户就可以从具体的产品中被解耦。

二、模式结构

抽象工厂模式的UML结构图如下:

img

模式结构说明。

AbstractFactory:抽象工厂。抽象工厂定义了一个接口,所有的具体工厂都必须实现此接口,这个接口包含了一组方法用来生产产品。

ConcreteFactory:具体工厂。具体工厂是用于生产不同产品族。要创建一个产品,客户只需要使用其中一个工厂完全不需要实例化任何产品对象。

AbstractProduct:抽象产品。这是一个产品家族,每一个具体工厂都能够生产一整组产品。

Product:具体产品。

三、模式实现

依然是披萨店。为了要保证每家加盟店都能够生产高质量的披萨,防止使用劣质的原料,我们打算建造一家生产原料的工厂,并将原料运送到各家加盟店。但是加盟店都位于不同的区域,比如纽约、芝加哥。纽约使用一组原料,芝加哥使用另一种原料。在这里我们可以这样理解,这些不同的区域组成了原料家族,每个区域实现了一个完整的原料家族。

img

首先创建一个原料工厂。该工厂为抽象工厂,负责创建所有的原料。

PizzaIngredientFactory.java

 1 public interface PizzaIngredientFactory {
2 /*
3 * 在接口中,每个原料都有一个对应的方法创建该原料
4 */
5 public Dough createDough();
6
7 public Sauce createSauce();
8
9 public Cheese createCheese();
10
11 public Veggies[] createVeggies();
12
13 public Pepperoni createPepperoni();
14
15 public Clams createClams();
16 }

原料工厂创建完成之后,需要创建具体的原料工厂。该具体工厂只需要继承PizzaIngredientFactory,然后实现里面的方法即可。

纽约原料工厂:NYPizzaIngredientFactory.java。

 1 public class NYPizzaIngredientFactory implements PizzaIngredientFactory{
2
3 @Override
4 public Cheese createCheese() {
5 return new ReggianoCheese();
6 }
7
8 @Override
9 public Clams createClams() {
10 return new FreshClams();
11 }
12
13 @Override
14 public Dough createDough() {
15 return new ThinCrustDough();
16 }
17
18 @Override
19 public Pepperoni createPepperoni() {
20 return new SlicedPepperoni();
21 }
22
23 @Override
24 public Sauce createSauce() {
25 return new MarinaraSauce();
26 }
27
28 @Override
29 public Veggies[] createVeggies() {
30 Veggies veggies[] = {new Garlic(),new Onion(),new Mushroom(),new RefPepper()};
31 return veggies;
32 }
33
34 }

重新返回到披萨。在这个披萨类里面,我们需要使用原料,其他方法保持不变,将prepare()方法声明为抽象,在这个方法中,我们需要收集披萨所需要的原料。

Pizza.java

 1 public abstract class Pizza {
2 /*
3 * 每个披萨都持有一组在准备时会用到的原料
4 */
5 String name;
6 Dough dough;
7 Sauce sauce;
8 Veggies veggies[];
9 Cheese cheese;
10 Pepperoni pepperoni;
11 Clams clams;
12
13 /*
14 * prepare()方法声明为抽象方法。在这个方法中,我们需要收集披萨所需要的原料,而这些原料都是来自原料工厂
15 */
16 abstract void prepare();
17
18 void bake(){
19 System.out.println("Bake for 25 munites at 350");
20 }
21
22 void cut(){
23 System.out.println("Cutting the pizza into diagonal slices");
24 }
25
26 void box(){
27 System.out.println("Place pizza in official PizzaStore box");
28 }
29
30 public String getName() {
31 return name;
32 }
33
34 public void setName(String name) {
35 this.name = name;
36 }
37
38 }

CheesePizza.java

 1 public class CheesePizza extends Pizza{
2 PizzaIngredientFactory ingredientFactory;
3
4 /*
5 * 要制作披萨必须要有制作披萨的原料,而这些原料是从原料工厂运来的
6 */
7 public CheesePizza(PizzaIngredientFactory ingredientFactory){
8 this.ingredientFactory = ingredientFactory;
9 prepare();
10 }
11
12 /
13 * 实现prepare方法
14 * prepare 方法一步一步地创建芝士比萨,每当需要原料时,就跟工厂要
15 */
16 void prepare() {
17 System.out.println("Prepareing " + name);
18 dough = ingredientFactory.createDough();
19 sauce = ingredientFactory.createSauce();
20 cheese = ingredientFactory.createCheese();
21 }
22
23 }

Pizza的代码利用相关的工厂生产原料。所生产的原料依赖所使用的工厂,Pizza类根本不关心这些原料,它只需要知道如何制作披萨即可。这里,Pizza和区域原料之间被解耦。

ClamPizza.java

 1  public class ClamPizza extends Pizza{
2
3 PizzaIngredientFactory ingredientFactory;
4
5 public ClamPizza(PizzaIngredientFactory ingredientFactory){
6 this.ingredientFactory = ingredientFactory;
7 }
8
9 @Override
10 void prepare() {
11 System.out.println("Prepare " + name);
12 dough = ingredientFactory.createDough();
13 sauce = ingredientFactory.createSauce();
14 cheese = ingredientFactory.createCheese();
15 clams = ingredientFactory.createClams();
16 }
17
18 }

做完披萨后,需要关注披萨店了。

在披萨店中,我们依然需要关注原料,当地的披萨店需要和本地的原料工厂关联起来。

PizzaStore.java

 1 public abstract class PizzaStore {
2 public Pizza orderPizza(String type){
3 Pizza pizza;
4 pizza = createPizza(type);
5
6 pizza.prepare();
7 pizza.bake();
8 pizza.cut();
9 pizza.box();
10
11 return pizza;
12 }
13
14 /*
15 * 创建pizza的方法交给子类去实现
16 */
17 abstract Pizza createPizza(String type);
18 }

纽约的披萨店:NYPizzaStore.java

 1 public class NYPizzaStore extends PizzaStore{
2
3 @Override
4 Pizza createPizza(String type) {
5 Pizza pizza = null;
6 //使用纽约的原料工厂
7 PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory();
8 if("cheese".equals(type)){
9 pizza = new CheesePizza(ingredientFactory);
10 pizza.setName("New York Style Cheese Pizza");
11 }
12 else if("veggie".equals(type)){
13 pizza = new VeggiePizza(ingredientFactory);
14 pizza.setName("New York Style Veggie Pizza");
15 }
16 else if("clam".equals(type)){
17 pizza = new ClamPizza(ingredientFactory);
18 pizza.setName("New York Style Clam Pizza");
19 }
20 else if("pepperoni".equals(type)){
21 pizza = new PepperoniPizza(ingredientFactory);
22 pizza.setName("New York Style Pepperoni Pizza");
23 }
24 return pizza;
25 }
26 }

下图是上面的UML结构图。

img

其中PizzaIngredientFactory是抽象的披萨原料工厂接口,它定义了如何生产一个相关产品的家族。这个家族包含了所有制作披萨的原料。

NYPizzaIngredientFactory和ChicagoPizzaIngredientFactory是两个具体披萨工厂类,他们负责生产相应的披萨原料。

NYPizzaStore是抽象工厂的客户端。

四、模式优缺点

优点

1、 抽象工厂隔离了具体类的生成,是的客户端不需要知道什么被创建。所有的具体工厂都实现了抽象工厂中定义的公共接口,因此只需要改变具体工厂的实例,就可以在某种程度上改变整个软件系统的行为。

2、 当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端始终只使用同一个产品族中的对象。

缺点

添加新的行为时比较麻烦。如果需要添加一个新产品族对象时,需要更改接口及其下所有子类,这必然会带来很大的麻烦。

五、模式使用场景

  1. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节,这对于所有类型的工厂模式都是重要的。

2.系统中有多于一个的产品族,而每次只使用其中某一产品族。

  1. 属于同一个产品族的产品将在一起使用,这一约束必须在系统的设计中体现出来。

  2. 系统提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于具体实现。

六、总结

1、 抽象工厂模式中主要的优点在于具体类的隔离,是的客户端不需要知道什么被创建了。其缺点在于增加新的等级产品结构比较复杂,需要修改接口及其所有子类。

666. 彩蛋

如果你对 设计模式 感兴趣,欢迎加入我的知识一起交流。

知识星球

文章目录
  1. 1. 一、基本定义
  2. 2. 二、模式结构
  3. 3. 三、模式实现
  4. 4. 四、模式优缺点
    1. 4.1. 优点
    2. 4.2. 缺点
  5. 5. 五、模式使用场景
  6. 6. 六、总结
  7. 7. 666. 彩蛋