设计模式之抽象工厂模式
序言
工厂方法模式通过引入工厂等级结构，解决了简单工厂模式中工厂类职责太重问题，由于工厂模式中的每个工厂只能生产一类产品，可能会导致大量的工厂类，，势必会增加系统的开销，此时可以考虑将一些相关的产品组成一个“产品族”，由同一个工厂来生产。———这也就是抽象工厂的基本思想。
产品等级结构与产品族
在讲抽象工厂模式之前，我们必须明白两个概念： 产品等级结构 、 产品族。
- 产品等级结构： 产品等级结构即产品的继承结构， 如一个抽象类是手游，其子类有腾讯的手游、 网易的手游、 盛大的手游等等。则抽象手游与具体游戏公司的手游构成一个产品等级结构，手游是父类，而其它具体公司的手游则是子类。
- 产品族： 在抽象工厂模式中，产品族是指由同一个工厂生产，位于不同产品等级结构中的一组产品。如腾讯公司生产的手游、端游、页游， 腾讯的手游则位于手游产品等级结构中，腾讯的端游则位于端游产品结构中， 腾讯的手游、 端游、 页游就构成了一个产品族。
我们看到不同的颜色的多个椭圆形、正方形、三角形分别构成了三个不同的产品等级结构，而颜色相同的椭圆、正方形、三角形构成一个产品族，可以看到每一个形状都位于某个产品族，并不属于某个产品等级结构，图中有4个产品族，分属于3个不同的产品等级结构。只要知道一个产品的所处的产品族和产品等级结构，就可以确定这个产品。
抽象工厂模式
定义：提供一个创建一系列相关或相互依赖的接口，而无需指定它们具体的类。抽象工厂模式又称为Kit模式，它也是一种对象创建型模式
在抽象工厂模式有一下几个角色：
- AbstractProduct(抽象产品)：为每种产品声明接口,在抽象产品中声明了产品所有的业务接口。
- ConcrteProduct(具体产品) ： 定义具体的工厂生产的具体产品对象，实现了抽象产品的所有方法。
- AbstractFactory(抽象工厂)：声明了创建一组用于创建一族产品的接口，每个方法对应一种产品。
- ConcreteFactory(具体工厂)：实现了抽象工厂中所有的接口，这些接口返回的产品构成了一个产品族，每个产品都位于某个产品等级结构中。
代码实现：
AbstractProduct(抽象产品)
/**
* @program
* @Desc 抽象 产品A
* @Author 游戏人日常
* @CreateTime 2019/07/15--18:56
*/
public abstract class AbstractProductA {
}
/**
* @program
* @Desc 抽象 产品B
* @Author 游戏人日常
* @CreateTime 2019/07/15--18:57
*/
public abstract class AbstractProductB {
}
ConcreteProduct(具体产品) ： 产品A和产品B构成产品族， A1和A2构成产品等级结构。
/**
* @program
* @Desc 具体的产品 A1
* @Author 游戏人日常
* @CreateTime 2019/07/15--19:04
*/
public class ConcreteProductA1 extends AbstractProductA{
}
/**
* @program
* @Desc 具体的产品 B1
* @Author 游戏人日常
* @CreateTime 2019/07/15--19:04
*/
public class ConcreteProductB1 extends AbstractProductB{
}
/**
* @program
* @Desc 具体的产品 A2
* @Author 游戏人日常
* @CreateTime 2019/07/15--19:03
*/
public class ConcreteProductA2 extends AbstractProductA{
}
/**
* @program
* @Desc 具体的产品 B2
* @Author 游戏人日常
* @CreateTime 2019/07/15--19:07
*/
public class ConcreteProductB2 extends AbstractProductB {
}
AbstractFactory(抽象工厂)
/**
* @program
* @Desc 抽象工厂
* @Author 游戏人日常
* @CreateTime 2019/07/15--19:16
*/
public abstract class AbstractFactory {
public abstract AbstractProductA createProductA();
public abstract AbstractProductB createProductB();
}
ConcreteFactory(具体工厂)
/**
* @program
* @Desc 具体工厂 1
* @Author 游戏人日常
* @CreateTime 2019/07/15--19:20
*/
public class ConcreteFactory1 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB1();
}
}
/**
* @program
* @Desc 具体工厂 2
* @Author 游戏人日常
* @CreateTime 2019/07/15--19:21
*/
public class ConcreteFactory2 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB2();
}
}
客户端测试：
/**
* @program
* @Desc
* @Author 游戏人日常
* @CreateTime 2019/07/15--19:25
*/
public class Test {
public static void main(String args[]){
//声明一个工厂1 就可以生产 A1和B1
AbstractFactory factory1= new ConcreteFactory1();
AbstractProductA productA1=factory1.createProductA();
AbstractProductB productB1=factory1.createProductB();
//声明一个工厂2 就可以生产 A2和B2
AbstractFactory factory2= new ConcreteFactory2();
AbstractProductA productA2=factory2.createProductA();
AbstractProductB productB2=factory2.createProductB();
}
}
“开闭原则”的倾斜性
在抽象工厂模式中，增加新的产品族很方便，但是增加新的产品等级结构就很麻烦，抽象工厂模式的这种性质称为**“开闭原则“的倾斜性**
- 增加产品族： 对于增加新的产品族，只需要增加个具体的产品并对应增加个具体工厂，对已有的代码不用修改，符合”开闭原则“。
- 增加新的产品等级结构： 对于增加新的产品等级结构，就需要修改工厂角色，包括抽象工厂，需要增加新产品的方法，相应的具体工厂也要改。 违背了”开闭原则“
”增加产品族“ 代码如下：
新增的产品族：
/**
* @program
* @Desc
* @Author 游戏人日常
* @CreateTime 2019/07/15--20:33
*/
public class ConcreteProductA3 extends AbstractProductA {
}
/**
* @program
* @Desc
* @Author 游戏人日常
* @CreateTime 2019/07/15--20:33
*/
public class ConcreteProductB3 extends AbstractProductB {
}
新增具体的工厂类
/**
* @program
* @Desc
* @Author 游戏人日常
* @CreateTime 2019/07/15--20:34
*/
public class ConcreteFactory3 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
return new ConcreteProductA3();
}
@Override
public AbstractProductB createProductB() {
return new ConcreteProductB3();
}
}
客户端测试：
/**
* @program
* @Desc
* @Author 游戏人日常
* @CreateTime 2019/07/15--19:25
*/
public class Test {
public static void main(String args[]){
//声明一个工厂1 就可以生产 A1和B1
AbstractFactory factory1= new ConcreteFactory1();
AbstractProductA productA1=factory1.createProductA();
AbstractProductB productB1=factory1.createProductB();
//声明一个工厂1 就可以生产 A2和B2
AbstractFactory factory2= new ConcreteFactory2();
AbstractProductA productA2=factory2.createProductA();
AbstractProductB productB2=factory2.createProductB();
//（新增） 声明一个工厂3 就可以生产 A3和B3
AbstractFactory factory3= new ConcreteFactory3();
AbstractProductA productA3=factory2.createProductA();
AbstractProductB productB3=factory2.createProductB();
}
}
总结
抽象工厂模式是工厂方法模式的进一步延申，继承了工厂方法模式的优点，也弥补了工厂方法模式的一些缺点。 工厂方法模式针对的是一个产品等级结构，而抽象工厂模式是面对多个产品等级结构。
抽象工厂模式增加产品族方便，无需修改代码，只需增加具体的产品类和具体工厂类，符合”开闭原则“。 增加产品等级结构就需要改工厂类（抽象和具体的工厂都改）
抽象模式优缺点
优点
- 抽象工厂模式隔离了具体类的生成，使得客户端并不需要知道什么被创建，由于这种隔离，更换一个具体工厂相对容易些。
- 当一个产品族中的多个对象被设计成一起工作时，这样能够保证客户端始终只使用同一个产品族中的对象。
- 增加新的产品族很方便，无需修改已有代码，符合“开闭原则”。
缺点
- 增加新的产品等级结构麻烦，需要对原来的系统有较大的修改，还会修改抽象层代码，这不符合”开闭原则“
适用场景
- 一个系统不应当依赖于产品实例如何被创建、组合和表达的细节，这对于所有的工厂模式都是很重要，用户无需关系对象的创建过程，将对象的创建与使用解耦。
- 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来，同一产品族的产品可以是没有任何关系，但是它们都具有一些共同的约束
- 产品等级结构稳定，设计完成后，不会向系统中增加新的产品等级结构。
